- enhancement: Add X86_64 AVX/AVX instruction descriptions to asm syntaxer.

- enhancement: Update to the newest x86 Assembly manual.

RedPandaIDE/RedPandaIDE.pro

@@ -8,7 +8,7 @@ isEmpty(APP_NAME) {
 }
 
 isEmpty(APP_VERSION) {
-    APP_VERSION = 2.16
+    APP_VERSION = 2.17
 }
 
 contains(QMAKE_HOST.arch, x86_64):{

RedPandaIDE/debugger.cpp

@@ -2814,6 +2814,22 @@ RegisterModel::RegisterModel(QObject *parent):QAbstractTableModel(parent)
         mRegisterDescriptions.insert("xmm14",tr("128-bit")+" "+"XMM");
         mRegisterDescriptions.insert("xmm15",tr("128-bit")+" "+"XMM");
 
+        mRegisterDescriptions.insert("ymm0",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm1",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm2",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm3",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm4",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm5",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm6",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm7",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm8",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm9",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm11",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm12",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm13",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm14",tr("256-bit")+" "+"YMM");
+        mRegisterDescriptions.insert("ymm15",tr("256-bit")+" "+"YMM");
+
         mRegisterDescriptions.insert("mxscr",tr("SSE status and control"));
 
 #endif
@@ -3152,7 +3168,7 @@ QVariant MemoryModel::data(const QModelIndex &index, int role) const
         if (col<line->datas.count()) {
             QString s =tr("dec: %1").arg(line->datas[col])
                     +"<br/>"
-                           +tr("hex: %1").arg(line->datas[col],2,16,QChar('0'))
+                    +tr("oct: %1").arg(line->datas[col],0,8)
                     +"<br/>"
                     +tr("bin: %1").arg(line->datas[col],8,2,QChar('0'))
                     +"<br/>";
@@ -3165,11 +3181,12 @@ QVariant MemoryModel::data(const QModelIndex &index, int role) const
                 chVal="\\t";
             } else if (line->datas[col]=='\r') {
                 chVal="\\r";
-            } else if (line->datas[col]>'\n' && line->datas[col]<127) {
+            } else if (line->datas[col]>=' ' && line->datas[col]<127) {
                 chVal=QChar(line->datas[col]);
             }
             if (!chVal.isEmpty()) {
-                s+=tr("ascii: \'%1\'").arg(chVal);
+                s+=tr("ascii: \'%1\'").arg(chVal)
+                        +"<br/>";
             }
             return s;
         }

RedPandaIDE/mainwindow.cpp

@@ -217,6 +217,7 @@ MainWindow::MainWindow(QWidget *parent)
     mMenuNew->setTitle(tr("New"));
     mMenuNew->addAction(ui->actionNew);
     mMenuNew->addAction(ui->actionNew_GAS_File);
+    mMenuNew->addAction(ui->actionNew_Text_File);
     mMenuNew->addAction(ui->actionNew_Project);
     mMenuNew->addSeparator();
     mMenuNew->addAction(ui->actionNew_Template);
@@ -9614,7 +9615,7 @@ void MainWindow::on_actionGNU_Assembler_Manual_triggered()
 
 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"));
+    QDesktopServices::openUrl(QUrl("https://docs.oracle.com/cd/E53394_01/html/E54851/index.html"));
 }
 
 
@@ -9639,3 +9640,18 @@ void MainWindow::on_actionAdd_Watchpoint_triggered()
     mDebugger->addWatchpoint(s);
 }
 
+
+void MainWindow::on_actionNew_Text_File_triggered()
+{
+    if (mProject) {
+        if (QMessageBox::question(this,
+                                  tr("New Project File?"),
+                                  tr("Do you want to add the new file to the project?"),
+                                  QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
+            newProjectUnitFile("txt");
+            return;
+        }
+    }
+    newEditor("txt");
+}
+

RedPandaIDE/mainwindow.h

@@ -800,6 +800,8 @@ private slots:
 
     void on_actionAdd_Watchpoint_triggered();
 
+    void on_actionNew_Text_File_triggered();
+
 private:
     Ui::MainWindow *ui;
     bool mFullInitialized;

RedPandaIDE/mainwindow.ui

@@ -3292,7 +3292,7 @@
     <string>Generate Assembly</string>
    </property>
    <property name="shortcut">
-    <string>Ctrl+F9</string>
+    <string>Ctrl+F12</string>
    </property>
   </action>
   <action name="actionTrim_trailing_spaces">
@@ -3346,6 +3346,11 @@
     <string>Add a watchpoint that's triggered when it's modified.</string>
    </property>
   </action>
+  <action name="actionNew_Text_File">
+   <property name="text">
+    <string>New Text File</string>
+   </property>
+  </action>
  </widget>
  <customwidgets>
   <customwidget>

RedPandaIDE/translations/RedPandaIDE_pt_BR.ts

@@ -5111,25 +5111,33 @@
         <source>New value: %1</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <source>Ctrl+F12</source>
+        <translation type="unfinished">Ctrl+F12</translation>
+    </message>
+    <message>
+        <source>New Text File</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>MemoryModel</name>
+    <message>
+        <source>ascii: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
     <message>
         <source>dec: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>hex: %1</source>
+        <source>oct: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <source>bin: %1</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>ascii: &apos;%1&apos;</source>
-        <translation type="unfinished"></translation>
-    </message>
 </context>
 <context>
     <name>NewClassDialog</name>
@@ -6804,6 +6812,10 @@
         <source>Stack segment selector</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <source>256-bit</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>ReplaceDialog</name>

RedPandaIDE/translations/RedPandaIDE_zh_TW.ts

@@ -4864,25 +4864,33 @@
         <source>New value: %1</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <source>Ctrl+F12</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>New Text File</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>MemoryModel</name>
+    <message>
+        <source>ascii: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
     <message>
         <source>dec: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>hex: %1</source>
+        <source>oct: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <source>bin: %1</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>ascii: &apos;%1&apos;</source>
-        <translation type="unfinished"></translation>
-    </message>
 </context>
 <context>
     <name>NewClassDialog</name>
@@ -6385,6 +6393,10 @@
         <source>Stack segment selector</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <source>256-bit</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>SearchDialog</name>

Red_Panda_CPP.pro

@@ -14,7 +14,7 @@ qsynedit.subdir = libs/qsynedit
 
 APP_NAME = RedPandaCPP
 
-APP_VERSION = 2.16
+APP_VERSION = 2.17
 
 # Add the dependencies so that the RedPandaIDE project can add the depended programs
 # into the main app bundle

libs/qsynedit/qsynedit/syntaxer/asm.cpp

@@ -1138,6 +1138,431 @@ void ASMSyntaxer::initData()
         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."));
+
+        //AVX/AVX2 Instructions
+        Instructions.insert("vaddpd",QObject::tr("Add Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vaddps",QObject::tr("Add Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vaddsd",QObject::tr("Add Scalar Double-Precision Floating-Point Values."));
+        Instructions.insert("vaddss",QObject::tr("Add Scalar Single-Precision Floating-Point Values."));
+        Instructions.insert("vaddsubpd",QObject::tr("Packed Double-FP Add/Subtract."));
+        Instructions.insert("vaddsubps",QObject::tr("Packed Single-FP Add/Subtract."));
+        Instructions.insert("vandnpd",QObject::tr("Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vandnps",QObject::tr("Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vandpd",QObject::tr("Bitwise Logical AND of Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vandps",QObject::tr("Bitwise Logical AND of Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vblendpd",QObject::tr("Blend Packed Double Precision Floating-Point Values."));
+        Instructions.insert("vblendps",QObject::tr("Blend Packed Single Precision Floating-Point Values."));
+        Instructions.insert("vblendvpd",QObject::tr("Variable Blend Packed Double Precision Floating-Point Values."));
+        Instructions.insert("vblendvps",QObject::tr("Variable Blend Packed Single Precision Floating-Point Values."));
+        Instructions.insert("vcmpeq_ospd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeq_uqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeq_uspd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpfalse_ospd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpfalsepd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpge_oqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpgepd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpgt_oqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpgtpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmple_oqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmplepd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmplt_oqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpltpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneq_oqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneq_ospd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneq_uspd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnge_uqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpngepd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpngt_uqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpngtpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnle_uqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnlepd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnlt_uqpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnltpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpord_spd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpordpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmppd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmptrue_uspd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmptruepd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpunord_spd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpunordpd",QObject::tr("Compare Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeq_osps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeq_uqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeq_usps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpfalse_osps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpfalseps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpge_oqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpgeps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpgt_oqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpgtps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmple_oqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpleps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmplt_oqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpltps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneq_oqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneq_osps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneq_usps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpneqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnge_uqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpngeps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpngt_uqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpngtps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnle_uqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnleps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnlt_uqps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpnltps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpord_sps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpordps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmptrue_usps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmptrueps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpunord_sps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpunordps",QObject::tr("Compare Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcmpeq_ossd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpeq_uqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpeq_ussd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpeqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpfalse_ossd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpfalsesd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpge_oqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpgesd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpgt_oqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpgtsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmple_oqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmplesd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmplt_oqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpltsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneq_oqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneq_ossd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneq_ussd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnge_uqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpngesd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpngt_uqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpngtsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnle_uqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnlesd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnlt_uqsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnltsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpord_ssd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpordsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmptrue_ussd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmptruesd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpunord_ssd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpunordsd",QObject::tr("Compare Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcmpeq_osss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpeq_uqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpeq_usss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpeqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpfalse_osss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpfalsess",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpge_oqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpgess",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpgt_oqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpgtss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmple_oqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpless",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmplt_oqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpltss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneq_oqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneq_osss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneq_usss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpneqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnge_uqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpngess",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpngt_uqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpngtss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnle_uqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnless",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnlt_uqss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpnltss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpord_sss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpordss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmptrue_usss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmptruess",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpunord_sss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcmpunordss",QObject::tr("Compare Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcomisd",QObject::tr("Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS."));
+        Instructions.insert("vcomiss",QObject::tr("Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS."));
+        Instructions.insert("vcvtdq2pd",QObject::tr("Convert Packed Doubleword Integers to Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vcvtdq2ps",QObject::tr("Convert Packed Doubleword Integers to Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcvtpd2dq",QObject::tr("Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers."));
+        Instructions.insert("vcvtpd2dqx",QObject::tr("Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers."));
+        Instructions.insert("vcvtpd2dqy",QObject::tr("Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers."));
+        Instructions.insert("vcvtpd2ps",QObject::tr("Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcvtpd2psx",QObject::tr("Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcvtpd2psy",QObject::tr("Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vcvtps2dq",QObject::tr("Convert Packed Single-Precision Floating-Point Values to Packed Signed Doubleword Integer Values."));
+        Instructions.insert("vcvtps2pd",QObject::tr("Convert Packed Single-Precision Floating-Point Values to Packed Double-Precision Floating-Point."));
+        Instructions.insert("vcvtsd2si",QObject::tr("Convert Scalar Double-Precision Floating-Point Value to Doubleword Integer."));
+        Instructions.insert("vcvtsd2siq",QObject::tr("Convert Scalar Double-Precision Floating-Point Value to quad word Integer."));
+        Instructions.insert("vcvtsd2sil",QObject::tr("Convert Scalar Double-Precision Floating-Point Value to double word Integer."));
+        Instructions.insert("vcvtsd2ss",QObject::tr("Convert Scalar Double-Precision Floating-Point Value to Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcvtsi2sd",QObject::tr("Convert Doubleword Integer to Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcvtsi2sdq",QObject::tr("Convert quad word Integer to Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcvtsi2sdl",QObject::tr("Convert double word Integer to Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcvtsi2ss",QObject::tr("Convert Doubleword Integer to Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcvtsi2ssq",QObject::tr("Convert quad word Integer to Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcvtsi2ssl",QObject::tr("Convert Doubleword Integer to Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vcvtss2sd",QObject::tr("Convert Scalar Single-Precision Floating-Point Value to Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vcvtss2si",QObject::tr("Convert Scalar Single-Precision Floating-Point Value to Doubleword Integer."));
+        Instructions.insert("vcvtss2siq",QObject::tr("Convert Scalar Single-Precision Floating-Point Value to quad word Integer."));
+        Instructions.insert("vcvtss2sil",QObject::tr("Convert Scalar Single-Precision Floating-Point Value to Doubleword Integer."));
+        Instructions.insert("vcvttpd2dq",QObject::tr("Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword."));
+        Instructions.insert("vcvttpd2dqx",QObject::tr("Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword."));
+        Instructions.insert("vcvttpd2dqy",QObject::tr("Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword."));
+        Instructions.insert("vcvttps2dq",QObject::tr("Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Signed Doubleword."));
+        Instructions.insert("vcvttsd2si",QObject::tr("Convert with Truncation Scalar Double-Precision Floating-Point Value to Signed Integer."));
+        Instructions.insert("vcvttsd2siq",QObject::tr("Convert with Truncation Scalar Double-Precision Floating-Point Value to Signed quad word Integer."));
+        Instructions.insert("vcvttsd2sil",QObject::tr("Convert with Truncation Scalar Double-Precision Floating-Point Value to Signed double word Integer."));
+        Instructions.insert("vcvttss2si",QObject::tr("Convert with Truncation Scalar Single-Precision Floating-Point Value to Integer."));
+        Instructions.insert("vcvttss2siq",QObject::tr("Convert with Truncation Scalar Single-Precision Floating-Point Value to quad word Integer."));
+        Instructions.insert("vcvttss2sil",QObject::tr("Convert with Truncation Scalar Single-Precision Floating-Point Value to double word Integer."));
+        Instructions.insert("vdivpd",QObject::tr("Divide Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vdivps",QObject::tr("Divide Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vdivsd",QObject::tr("Divide Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vdivss",QObject::tr("Divide Scalar Single-Precision Floating-Point Values."));
+        Instructions.insert("vdppd",QObject::tr("Dot Product of Packed Double Precision Floating-Point Values."));
+        Instructions.insert("vdpps",QObject::tr("Dot Product of Packed Single Precision Floating-Point Values."));
+        Instructions.insert("vextractps",QObject::tr("Extract Packed Floating-Point Values."));
+        Instructions.insert("vhaddpd",QObject::tr("Packed Double-FP Horizontal Add."));
+        Instructions.insert("vhaddps",QObject::tr("Packed Single-FP Horizontal Add."));
+        Instructions.insert("vhsubpd",QObject::tr("Packed Double-FP Horizontal Subtract."));
+        Instructions.insert("vhsubps",QObject::tr("Packed Single-FP Horizontal Subtract."));
+        Instructions.insert("vinsertps",QObject::tr("Insert Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vlddqu",QObject::tr("Load Unaligned Integer 128 Bits."));
+        Instructions.insert("vldmxcsr",QObject::tr("Load MXCSR Register."));
+        Instructions.insert("vmaskmovdqu",QObject::tr("Store Selected Bytes of Double Quadword."));
+        Instructions.insert("vmaxpd",QObject::tr("Maximum of Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vmaxps",QObject::tr("Maximum of Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vmaxsd",QObject::tr("Return Maximum Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vmaxss",QObject::tr("Return Maximum Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vminpd",QObject::tr("Minimum of Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vminps",QObject::tr("Minimum of Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vminsd",QObject::tr("Return Minimum Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vminss",QObject::tr("Return Minimum Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vmovapd",QObject::tr("Move Aligned Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vmovaps",QObject::tr("Move Aligned Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vmov",QObject::tr("Move Doubleword and Quadword."));
+        Instructions.insert("vmovq",QObject::tr("Move Quadword."));
+        Instructions.insert("vmovd",QObject::tr("Move Doubleword."));
+        Instructions.insert("vmovddup",QObject::tr("Replicate Double FP Values."));
+        Instructions.insert("vmovdqa",QObject::tr("Move Aligned Packed Integer Values."));
+        Instructions.insert("vmovdqu",QObject::tr("Move Unaligned Packed Integer Values."));
+
+
+        Instructions.insert("vmovhlps",QObject::tr("Move Packed Single-Precision Floating-Point Values High to Low."));
+        Instructions.insert("vmovhpd",QObject::tr("Move High Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vmovhps",QObject::tr("Move High Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vmovlhps",QObject::tr("Move Packed Single-Precision Floating-Point Values Low to High."));
+        Instructions.insert("vmovlpd",QObject::tr("Move Low Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vmovlps",QObject::tr("Move Low Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vmovmskpd",QObject::tr("Extract Packed Double-Precision Floating-Point Sign Mask."));
+        Instructions.insert("vmovmskps",QObject::tr("Extract Packed Single-Precision Floating-Point Sign Mask."));
+        Instructions.insert("vmovntdq",QObject::tr("Store Packed Integers Using Non-Temporal Hint."));
+        Instructions.insert("vmovntdqa",QObject::tr("Load Double Quadword Non-Temporal Aligned Hint."));
+        Instructions.insert("vmovntpd",QObject::tr("Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint."));
+        Instructions.insert("vmovntps",QObject::tr("Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint."));
+        Instructions.insert("vmovq",QObject::tr("Move Quadword."));
+        Instructions.insert("vmovsd",QObject::tr("Move or Merge Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vmovshdup",QObject::tr("Replicate Single FP Values."));
+        Instructions.insert("vmovsldup",QObject::tr("Replicate Single FP Values."));
+        Instructions.insert("vmovss",QObject::tr("Move or Merge Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vmovupd",QObject::tr("Move Unaligned Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vmovups",QObject::tr("Move Unaligned Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vmpsadbw",QObject::tr("Compute Multiple Packed Sums of Absolute Difference."));
+        Instructions.insert("vmulpd",QObject::tr("Multiply Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vmulps",QObject::tr("Multiply Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vmulsd",QObject::tr("Multiply Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vmulss",QObject::tr("Multiply Scalar Single-Precision Floating-Point Values."));
+        Instructions.insert("vorpd",QObject::tr("Bitwise Logical OR of Double-Precision Floating-Point Values."));
+        Instructions.insert("vorps",QObject::tr("Bitwise Logical OR of Single-Precision Floating-Point Values."));
+        Instructions.insert("vpabsq",QObject::tr("Packed Absolute Quadword Value."));
+        Instructions.insert("vpabsw",QObject::tr("Packed Absolute Word Value."));
+        Instructions.insert("vpabsb",QObject::tr("Packed Absolute Byte Value."));
+        Instructions.insert("vpabsd)",QObject::tr("Packed Absolute Doubleword Value."));
+        Instructions.insert("vpackssdw",QObject::tr("Pack with Signed Saturation."));
+        Instructions.insert("vpacksswb",QObject::tr("Pack with Signed Saturation."));
+        Instructions.insert("vpackusdw",QObject::tr("Pack with Unsigned Saturation."));
+        Instructions.insert("vpackuswb",QObject::tr("Pack with Unsigned Saturation."));
+        Instructions.insert("vpaddq",QObject::tr("Add Packed Quadword Integers."));
+        Instructions.insert("vpaddw",QObject::tr("Add Packed Word Integers."));
+        Instructions.insert("vpaddb",QObject::tr("Add Packed Byte Integers."));
+        Instructions.insert("vpaddd",QObject::tr("Add Packed Doubleword Integers."));
+
+        Instructions.insert("vpaddsw",QObject::tr("Add Packed Signed Word Integers with Signed Saturation."));
+        Instructions.insert("vpaddsb",QObject::tr("Add Packed Signed Byte Integers with Signed Saturation."));
+
+        Instructions.insert("vpaddusw",QObject::tr("Add Packed Unsigned Word Integers with Unsigned Saturation."));
+        Instructions.insert("vpaddusb",QObject::tr("Add Packed Unsigned Byte Integers with Unsigned Saturation."));
+
+        Instructions.insert("vpalignr",QObject::tr("Packed Align Right."));
+        Instructions.insert("vpand",QObject::tr("Logical AND."));
+        Instructions.insert("vpandn",QObject::tr("Logical AND NOT."));
+        Instructions.insert("vpavgw",QObject::tr("Average Packed Word Integers."));
+        Instructions.insert("vpavgb",QObject::tr("Average Packed Byte Integers."));
+
+        Instructions.insert("vpblendvb",QObject::tr("Variable Blend Packed Bytes."));
+        Instructions.insert("vpblendw",QObject::tr("Blend Packed Words."));
+        Instructions.insert("vpcmpeqq",QObject::tr("Compare Packed Quadword Integers for Equality."));
+        Instructions.insert("vpcmpeqw",QObject::tr("Compare Packed Word Integers for Equality."));
+        Instructions.insert("vpcmpeqb",QObject::tr("Compare Packed Byte Integers for Equality."));
+        Instructions.insert("vpcmpeqd",QObject::tr("Compare Packed Doubleword Integers for Equality."));
+
+        Instructions.insert("vpcmpestri",QObject::tr("Packed Compare Explicit Length Strings, Return Index."));
+        Instructions.insert("vpcmpestrm",QObject::tr("Packed Compare Explicit Length Strings, Return Mask."));
+        Instructions.insert("vpcmpgtq",QObject::tr("Compare Packed Quadword Integers for Greater Than."));
+        Instructions.insert("vpcmpgtw",QObject::tr("Compare Packed Word Integers for Greater Than."));
+        Instructions.insert("vpcmpgtb",QObject::tr("Compare Packed Byte Integers for Greater Than."));
+        Instructions.insert("vpcmpgtd",QObject::tr("Compare Packed Doubleword Integers for Greater Than."));
+
+        Instructions.insert("vpcmpistri",QObject::tr("Packed Compare Implicit Length Strings, Return Index."));
+        Instructions.insert("vpcmpistrm",QObject::tr("Packed Compare Implicit Length Strings, Return Mask."));
+        Instructions.insert("vpextrq",QObject::tr("Extract Quadword."));
+        Instructions.insert("vpextrb",QObject::tr("Extract Byte."));
+        Instructions.insert("vpextrd",QObject::tr("Extract Doubleword."));
+
+
+        Instructions.insert("vpextrw",QObject::tr("Extract Word."));
+        Instructions.insert("vphaddsw",QObject::tr("Packed Horizontal Add and Saturate."));
+        Instructions.insert("vphaddw",QObject::tr("Packed Horizontal Add Word."));
+        Instructions.insert("vphaddd",QObject::tr("Packed Horizontal Add Doubleword."));
+
+        Instructions.insert("vphminposuw",QObject::tr("Packed Horizontal Word Minimum."));
+        Instructions.insert("vphsubsw",QObject::tr("Packed Horizontal Subtract and Saturate."));
+        Instructions.insert("vphsubw",QObject::tr("Packed Horizontal Subtract Word."));
+        Instructions.insert("vphsubd",QObject::tr("Packed Horizontal Subtract Doubleword."));
+        Instructions.insert("vpinsrq",QObject::tr("Insert Quadword."));
+        Instructions.insert("vpinsrb",QObject::tr("Insert Byte."));
+        Instructions.insert("vpinsrw",QObject::tr("Insert Word."));
+        Instructions.insert("vpinsrd",QObject::tr("Insert Doubleword."));
+        Instructions.insert("vpinsrw",QObject::tr("Insert Word."));
+        Instructions.insert("vpmaddubsw",QObject::tr("Multiply and Add Packed Signed and Unsigned Bytes."));
+        Instructions.insert("vpmaddwd",QObject::tr("Multiply and Add Packed Integers."));
+        Instructions.insert("vvpmaxsq",QObject::tr("Maximum of Packed Signed Quadword Integers."));
+        Instructions.insert("vvpmaxsw",QObject::tr("Maximum of Packed Signed Word Integers."));
+        Instructions.insert("vvpmaxsb",QObject::tr("Maximum of Packed Signed Byte Integers."));
+        Instructions.insert("vvpmaxsd",QObject::tr("Maximum of Packed Signed Doubleword Integers."));
+        Instructions.insert("vpmaxub",QObject::tr("Maximum of Packed Unsigned Byte Integers."));
+        Instructions.insert("vpmaxud",QObject::tr("Maximum of Packed Unsigned Integers."));
+        Instructions.insert("vpmaxuw",QObject::tr("Maximum of Packed Word Integers."));
+        Instructions.insert("vpminsb",QObject::tr("Minimum of Packed Signed Byte Integers."));
+        Instructions.insert("vpminsd",QObject::tr("Minimum of Packed Signed Integers."));
+        Instructions.insert("vpminsw",QObject::tr("Minimum of Packed Signed Word Integers."));
+        Instructions.insert("vpminub",QObject::tr("Minimum of Packed Unsigned Byte Integers."));
+        Instructions.insert("vpminud",QObject::tr("Minimum of Packed Unsigned Integers."));
+        Instructions.insert("vpminuw",QObject::tr("Minimum of Packed Word Integers."));
+        Instructions.insert("vpmovmskb",QObject::tr("Move Byte Mask."));
+        Instructions.insert("vpmovsxbd",QObject::tr("Packed Move byte to double word with Sign Extend."));
+        Instructions.insert("vpmovsxbq",QObject::tr("Packed Move byte to quad word with Sign Extend."));
+        Instructions.insert("vpmovsxbw",QObject::tr("Packed Move byte to word with Sign Extend."));
+        Instructions.insert("vpmovsxdq",QObject::tr("Packed Move double word to quad word with Sign Extend."));
+        Instructions.insert("vpmovsxwd)",QObject::tr("Packed Move word to double word with Sign Extend."));
+        Instructions.insert("vpmovsxwq)",QObject::tr("Packed Move word to quad word with Sign Extend."));
+        Instructions.insert("vpmovzxbd",QObject::tr("Packed Move byte to double word with Zero Extend."));
+        Instructions.insert("vpmovzxbq",QObject::tr("Packed Move byte to quad word with Zero Extend."));
+        Instructions.insert("vpmovzxbw",QObject::tr("Packed Move byte to word with Zero Extend."));
+        Instructions.insert("vpmovzxdq",QObject::tr("Packed Move double word to quad word with Zero Extend."));
+        Instructions.insert("vpmovzxwd)",QObject::tr("Packed Move word to double word with Zero Extend."));
+        Instructions.insert("vpmovzxwq)",QObject::tr("Packed Move word to quad word with Zero Extend."));
+        Instructions.insert("vpmuldq",QObject::tr("Multiply Packed Doubleword Integers."));
+        Instructions.insert("vpmulhrsw",QObject::tr("Packed Multiply High with Round and Scale."));
+        Instructions.insert("vpmulhuw",QObject::tr("Multiply Packed Unsigned Integers and Store High Result."));
+        Instructions.insert("vpmulhw",QObject::tr("Multiply Packed Signed Integers and Store High Result."));
+        Instructions.insert("vpmulld",QObject::tr("Multiply Packed Integers and Store Low Result."));
+        Instructions.insert("vpmullw",QObject::tr("Multiply Packed Signed Integers and Store Low Result."));
+        Instructions.insert("vpmuludq",QObject::tr("Multiply Packed Unsigned Doubleword Integers."));
+        Instructions.insert("vpor",QObject::tr("Bitwise Logical Or."));
+        Instructions.insert("vpsadbw",QObject::tr("Compute Sum of Absolute Differences."));
+        Instructions.insert("vpshufb",QObject::tr("Packed Shuffle Bytes."));
+        Instructions.insert("vpshufd",QObject::tr("Shuffle Packed Doublewords."));
+        Instructions.insert("vpshufhw",QObject::tr("Shuffle Packed High Words."));
+        Instructions.insert("vpshuflw",QObject::tr("Shuffle Packed Low Words."));
+        Instructions.insert("vpsignw",QObject::tr("Packed SIGN Word."));
+        Instructions.insert("vpsignb",QObject::tr("Packed SIGN Byte."));
+        Instructions.insert("vpsignd",QObject::tr("Packed SIGN Doubleword."));
+
+        Instructions.insert("vpslldq",QObject::tr("Shift Double Quadword Left Logical."));
+        Instructions.insert("vpsllq",QObject::tr("Bit Shift Left Quadword."));
+        Instructions.insert("vpsllw",QObject::tr("Bit Shift Left Word."));
+        Instructions.insert("vpslld",QObject::tr("Bit Shift Left Doubleword."));
+
+        Instructions.insert("vpsraw",QObject::tr("Bit Shift Arithmetic Right Word."));
+        Instructions.insert("vpsrad",QObject::tr("Bit Shift Arithmetic Right Doubleword."));
+        Instructions.insert("vpsrldq",QObject::tr("Shift Double Quadword Right Logical."));
+        Instructions.insert("vpsrlq",QObject::tr("Shift Packed Data Right Logical Quadword."));
+        Instructions.insert("vpsrlw",QObject::tr("Shift Packed Data Right Logical Word."));
+        Instructions.insert("vpsrld",QObject::tr("Shift Packed Data Right Logical Doubleword."));
+
+        Instructions.insert("vpsubq",QObject::tr("Packed Quadword Integer Subtract."));
+        Instructions.insert("vpsubw",QObject::tr("Packed Word Integer Subtract."));
+        Instructions.insert("vpsubb",QObject::tr("Packed Byte Integer Subtract."));
+        Instructions.insert("vpsubd",QObject::tr("Packed Doubleword Integer Subtract."));
+
+        Instructions.insert("vpsubsw",QObject::tr("Subtract Packed Signed Word Integers with Signed Saturation."));
+        Instructions.insert("vpsubsb",QObject::tr("Subtract Packed Signed Byte Integers with Signed Saturation."));
+
+        Instructions.insert("vpsubusw",QObject::tr("Subtract Packed Unsigned Word Integers with Unsigned Saturation."));
+        Instructions.insert("vpsubusb",QObject::tr("Subtract Packed Unsigned Byte Integers with Unsigned Saturation."));
+
+        Instructions.insert("vptest",QObject::tr("Logical Compare."));
+        Instructions.insert("vpunpckhbw",QObject::tr("Unpack High Data."));
+        Instructions.insert("vpunpckhdq",QObject::tr("Unpack High Data."));
+        Instructions.insert("vpunpckhqdq",QObject::tr("Unpack High Data."));
+        Instructions.insert("vpunpckhwd",QObject::tr("Unpack High Data."));
+        Instructions.insert("vpunpcklbw",QObject::tr("Unpack Low Data."));
+        Instructions.insert("vpunpckldq",QObject::tr("Unpack Low Data."));
+        Instructions.insert("vpunpcklqdq",QObject::tr("Unpack Low Data."));
+        Instructions.insert("vpunpcklwd",QObject::tr("Unpack Low Data."));
+
+        Instructions.insert("vpxor",QObject::tr("Exclusive Or."));
+
+        Instructions.insert("vrcpps",QObject::tr("Compute Reciprocals of Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vrcpss",QObject::tr("Compute Reciprocal of Scalar Single-Precision Floating-Point Values."));
+        Instructions.insert("vroundpd",QObject::tr("Round Packed Double Precision Floating-Point Values."));
+        Instructions.insert("vroundps",QObject::tr("Round Packed Single Precision Floating-Point Values."));
+        Instructions.insert("vroundsd",QObject::tr("Round Scalar Double Precision Floating-Point Values."));
+        Instructions.insert("vroundss",QObject::tr("Round Scalar Single Precision Floating-Point Values."));
+        Instructions.insert("vrsqrtps",QObject::tr("Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vrsqrtss",QObject::tr("Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vshufpd",QObject::tr("Shuffle Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vshufps",QObject::tr("Shuffle Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vsqrtpd",QObject::tr("Square Root of Double-Precision Floating-Point Values."));
+        Instructions.insert("vsqrtps",QObject::tr("Square Root of Single-Precision Floating-Point Values."));
+        Instructions.insert("vsqrtsd",QObject::tr("Compute Square Root of Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vsqrtss",QObject::tr("Compute Square Root of Scalar Single-Precision Value."));
+        Instructions.insert("vstmxcsr",QObject::tr("Store MXCSR Register State."));
+        Instructions.insert("vsubpd",QObject::tr("Subtract Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vsubps",QObject::tr("Subtract Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vsubsd",QObject::tr("Subtract Scalar Double-Precision Floating-Point Value."));
+        Instructions.insert("vsubss",QObject::tr("Subtract Scalar Single-Precision Floating-Point Value."));
+        Instructions.insert("vucomisd",QObject::tr("Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS."));
+        Instructions.insert("vucomiss",QObject::tr("Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS."));
+        Instructions.insert("vunpckhpd",QObject::tr("Unpack and Interleave High Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vunpckhps",QObject::tr("Unpack and Interleave High Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vunpcklpd",QObject::tr("Unpack and Interleave Low Packed Double-Precision Floating-Point Values."));
+        Instructions.insert("vunpcklps",QObject::tr("Unpack and Interleave Low Packed Single-Precision Floating-Point Values."));
+        Instructions.insert("vbroadcastf128",QObject::tr("Load with Broadcast Floating-Point Data."));
+        Instructions.insert("vbroadcastsd",QObject::tr("Load with Broadcast Double-Precision Floating-Point Data."));
+        Instructions.insert("vbroadcastss",QObject::tr("Load with Broadcast Single-Precision Floating-Point Data."));
+        Instructions.insert("vextractf128",QObject::tr("Extract Packed Floating-Point Values."));
+        Instructions.insert("vinsertf128",QObject::tr("Insert Packed Floating-Point Values."));
+        Instructions.insert("vmaskmovpd",QObject::tr("Conditional SIMD Packed Double-Precision Loads and Stores."));
+        Instructions.insert("vmaskmovps",QObject::tr("Conditional SIMD Packed Single-Precision Loads and Stores."));
+        Instructions.insert("vperm2f128",QObject::tr("Permute Floating-Point Values."));
+        Instructions.insert("vpermilpd",QObject::tr("Permute Double-Precision Floating-Point Values."));
+        Instructions.insert("vpermilps",QObject::tr("Permute Single-Precision Floating-Point Values."));
+        Instructions.insert("vtestpd",QObject::tr("Packed Double-Precision Bit Test."));
+        Instructions.insert("vtestps",QObject::tr("Packed Single-Precision Bit Test."));
+        Instructions.insert("vzeroall",QObject::tr("Zero All YMM Registers."));
+        Instructions.insert("vzeroupper",QObject::tr("Zero Upper Bits of YMM Registers."));
+        Instructions.insert("vxorpd",QObject::tr("Bitwise Logical XOR for Double-Precision Floating-Point Values."));
+        Instructions.insert("vxorps",QObject::tr("Bitwise Logical XOR for Single-Precision Floating-Point Values."));
+        Instructions.insert("vpclmulqdq",QObject::tr("Carry-Less Multiplication Quadword, Requires PCLMULQDQ CPUID-flag."));
 #endif
         InstructionNames=QSet<QString>(Instructions.keyBegin(),Instructions.keyEnd());
     }