# Generated from nasm_x86_64_Parser.g4 by ANTLR 4.13.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,2627,889,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,1,0,5,0,212,8,0,10,0,12,0,215,9,0,1,0,1,0,1,1,3,1,220,
        8,1,1,1,1,1,3,1,224,8,1,1,1,1,1,3,1,228,8,1,3,1,230,8,1,1,1,1,1,
        1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,
        1,3,3,3,251,8,3,1,3,1,3,3,3,255,8,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,
        1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,271,8,3,1,3,1,3,1,3,1,3,1,3,1,3,
        3,3,279,8,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,287,8,3,1,3,1,3,1,3,1,3,
        1,3,1,3,1,3,1,3,1,3,1,3,3,3,299,8,3,1,3,4,3,302,8,3,11,3,12,3,303,
        1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,316,8,3,1,4,1,4,1,5,
        1,5,1,6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10,1,10,1,11,1,11,3,11,334,
        8,11,1,11,3,11,337,8,11,1,11,3,11,340,8,11,1,11,3,11,343,8,11,1,
        11,3,11,346,8,11,1,11,3,11,349,8,11,1,11,3,11,352,8,11,1,11,3,11,
        355,8,11,1,11,3,11,358,8,11,1,11,3,11,361,8,11,1,11,1,11,3,11,365,
        8,11,1,11,3,11,368,8,11,1,11,1,11,3,11,372,8,11,1,11,3,11,375,8,
        11,1,11,3,11,378,8,11,1,12,1,12,1,13,1,13,1,14,1,14,1,15,1,15,1,
        15,1,15,1,16,1,16,1,16,1,16,1,17,1,17,1,18,1,18,1,19,1,19,1,20,1,
        20,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22,1,23,1,23,1,24,1,24,1,
        24,1,24,1,25,1,25,1,25,1,25,3,25,420,8,25,1,26,1,26,1,26,1,26,1,
        26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30,1,30,1,31,1,31,1,31,1,
        31,3,31,440,8,31,3,31,442,8,31,1,31,1,31,5,31,446,8,31,10,31,12,
        31,449,9,31,1,32,3,32,452,8,32,1,32,1,32,1,32,1,32,3,32,458,8,32,
        1,33,1,33,1,34,1,34,1,35,1,35,1,36,1,36,1,36,3,36,469,8,36,1,36,
        3,36,472,8,36,1,36,3,36,475,8,36,1,36,3,36,478,8,36,1,36,1,36,5,
        36,482,8,36,10,36,12,36,485,9,36,1,37,1,37,1,38,1,38,1,39,1,39,1,
        40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,3,41,502,8,41,3,41,504,
        8,41,4,41,506,8,41,11,41,12,41,507,1,41,3,41,511,8,41,1,42,1,42,
        1,43,1,43,1,44,1,44,1,45,1,45,1,46,1,46,1,47,1,47,1,48,1,48,1,49,
        1,49,1,50,1,50,1,50,3,50,532,8,50,1,51,1,51,1,52,1,52,1,53,1,53,
        1,54,1,54,1,55,1,55,1,56,1,56,1,57,1,57,1,58,1,58,1,59,1,59,1,60,
        1,60,1,61,1,61,3,61,556,8,61,1,61,1,61,1,61,1,61,5,61,562,8,61,10,
        61,12,61,565,9,61,1,62,1,62,1,63,1,63,1,64,1,64,1,64,1,64,1,65,1,
        65,1,66,1,66,1,67,1,67,1,67,3,67,582,8,67,1,68,1,68,1,69,3,69,587,
        8,69,1,69,1,69,1,69,1,69,5,69,593,8,69,10,69,12,69,596,9,69,1,69,
        1,69,1,69,1,69,1,69,1,69,1,69,5,69,605,8,69,10,69,12,69,608,9,69,
        1,69,1,69,1,69,3,69,613,8,69,3,69,615,8,69,1,70,1,70,1,71,1,71,1,
        72,1,72,1,73,1,73,1,74,1,74,1,75,1,75,1,76,1,76,1,76,1,76,1,76,1,
        76,3,76,635,8,76,1,77,1,77,1,77,1,77,1,77,1,77,3,77,643,8,77,1,78,
        1,78,1,79,1,79,1,79,1,79,1,79,3,79,652,8,79,1,79,1,79,3,79,656,8,
        79,1,80,1,80,1,80,3,80,661,8,80,1,80,3,80,664,8,80,1,80,1,80,1,81,
        1,81,1,81,1,81,5,81,672,8,81,10,81,12,81,675,9,81,1,81,1,81,1,82,
        1,82,1,82,1,82,1,82,1,82,1,82,3,82,686,8,82,1,83,1,83,1,84,1,84,
        1,84,1,84,1,84,1,84,3,84,696,8,84,1,84,1,84,1,84,1,84,1,84,3,84,
        703,8,84,1,85,1,85,1,85,5,85,708,8,85,10,85,12,85,711,9,85,1,86,
        1,86,1,86,5,86,716,8,86,10,86,12,86,719,9,86,1,87,1,87,1,87,5,87,
        724,8,87,10,87,12,87,727,9,87,1,88,1,88,1,88,5,88,732,8,88,10,88,
        12,88,735,9,88,1,89,1,89,1,89,5,89,740,8,89,10,89,12,89,743,9,89,
        1,90,1,90,1,90,5,90,748,8,90,10,90,12,90,751,9,90,1,91,1,91,1,91,
        5,91,756,8,91,10,91,12,91,759,9,91,1,92,1,92,1,92,5,92,764,8,92,
        10,92,12,92,767,9,92,1,93,1,93,1,93,5,93,772,8,93,10,93,12,93,775,
        9,93,1,94,1,94,1,94,5,94,780,8,94,10,94,12,94,783,9,94,1,95,1,95,
        1,95,1,95,1,95,1,95,3,95,791,8,95,1,96,1,96,1,97,1,97,1,98,1,98,
        3,98,799,8,98,1,98,1,98,5,98,803,8,98,10,98,12,98,806,9,98,1,98,
        3,98,809,8,98,1,99,1,99,1,100,3,100,814,8,100,1,100,1,100,1,100,
        3,100,819,8,100,1,100,1,100,1,100,1,100,1,100,1,100,3,100,827,8,
        100,1,100,3,100,830,8,100,1,100,3,100,833,8,100,1,100,1,100,1,100,
        1,100,1,100,1,100,1,100,5,100,842,8,100,10,100,12,100,845,9,100,
        1,100,1,100,3,100,849,8,100,1,100,3,100,852,8,100,1,101,1,101,1,
        102,1,102,1,103,1,103,3,103,860,8,103,1,103,1,103,5,103,864,8,103,
        10,103,12,103,867,9,103,1,103,1,103,3,103,871,8,103,1,103,1,103,
        5,103,875,8,103,10,103,12,103,878,9,103,1,103,3,103,881,8,103,1,
        104,1,104,1,104,1,104,3,104,887,8,104,1,104,0,0,105,0,2,4,6,8,10,
        12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,
        56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,
        100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,
        132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,
        164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,
        196,198,200,202,204,206,208,0,29,1,0,2526,2529,2,0,2531,2531,2533,
        2533,2,0,2538,2538,2562,2564,2,0,2575,2580,2583,2588,2,0,2554,2555,
        2590,2593,1,0,2596,2597,1,0,2598,2599,1,0,2600,2601,1,0,2556,2557,
        2,0,2551,2551,2553,2553,2,0,2613,2613,2615,2617,2,0,2578,2578,2603,
        2604,2,0,2525,2525,2607,2609,1,0,2605,2606,3,0,2525,2525,2539,2539,
        2544,2548,1,0,53,55,1,0,2621,2622,3,0,2530,2530,2532,2532,2559,2561,
        1,0,1,8,1,0,9,16,1,0,18,25,2,0,53,54,60,61,1,0,55,59,1,0,53,54,1,
        0,49,52,2,0,41,43,45,45,1,0,37,40,2,0,64,559,811,2521,1,0,560,810,
        920,0,213,1,0,0,0,2,219,1,0,0,0,4,233,1,0,0,0,6,315,1,0,0,0,8,317,
        1,0,0,0,10,319,1,0,0,0,12,321,1,0,0,0,14,323,1,0,0,0,16,325,1,0,
        0,0,18,327,1,0,0,0,20,329,1,0,0,0,22,331,1,0,0,0,24,379,1,0,0,0,
        26,381,1,0,0,0,28,383,1,0,0,0,30,385,1,0,0,0,32,389,1,0,0,0,34,393,
        1,0,0,0,36,395,1,0,0,0,38,397,1,0,0,0,40,399,1,0,0,0,42,401,1,0,
        0,0,44,405,1,0,0,0,46,409,1,0,0,0,48,411,1,0,0,0,50,419,1,0,0,0,
        52,421,1,0,0,0,54,427,1,0,0,0,56,429,1,0,0,0,58,431,1,0,0,0,60,433,
        1,0,0,0,62,435,1,0,0,0,64,451,1,0,0,0,66,459,1,0,0,0,68,461,1,0,
        0,0,70,463,1,0,0,0,72,465,1,0,0,0,74,486,1,0,0,0,76,488,1,0,0,0,
        78,490,1,0,0,0,80,492,1,0,0,0,82,494,1,0,0,0,84,512,1,0,0,0,86,514,
        1,0,0,0,88,516,1,0,0,0,90,518,1,0,0,0,92,520,1,0,0,0,94,522,1,0,
        0,0,96,524,1,0,0,0,98,526,1,0,0,0,100,531,1,0,0,0,102,533,1,0,0,
        0,104,535,1,0,0,0,106,537,1,0,0,0,108,539,1,0,0,0,110,541,1,0,0,
        0,112,543,1,0,0,0,114,545,1,0,0,0,116,547,1,0,0,0,118,549,1,0,0,
        0,120,551,1,0,0,0,122,553,1,0,0,0,124,566,1,0,0,0,126,568,1,0,0,
        0,128,570,1,0,0,0,130,574,1,0,0,0,132,576,1,0,0,0,134,578,1,0,0,
        0,136,583,1,0,0,0,138,586,1,0,0,0,140,616,1,0,0,0,142,618,1,0,0,
        0,144,620,1,0,0,0,146,622,1,0,0,0,148,624,1,0,0,0,150,626,1,0,0,
        0,152,634,1,0,0,0,154,642,1,0,0,0,156,644,1,0,0,0,158,655,1,0,0,
        0,160,657,1,0,0,0,162,667,1,0,0,0,164,685,1,0,0,0,166,687,1,0,0,
        0,168,702,1,0,0,0,170,704,1,0,0,0,172,712,1,0,0,0,174,720,1,0,0,
        0,176,728,1,0,0,0,178,736,1,0,0,0,180,744,1,0,0,0,182,752,1,0,0,
        0,184,760,1,0,0,0,186,768,1,0,0,0,188,776,1,0,0,0,190,784,1,0,0,
        0,192,792,1,0,0,0,194,794,1,0,0,0,196,808,1,0,0,0,198,810,1,0,0,
        0,200,851,1,0,0,0,202,853,1,0,0,0,204,855,1,0,0,0,206,857,1,0,0,
        0,208,886,1,0,0,0,210,212,3,2,1,0,211,210,1,0,0,0,212,215,1,0,0,
        0,213,211,1,0,0,0,213,214,1,0,0,0,214,216,1,0,0,0,215,213,1,0,0,
        0,216,217,5,0,0,1,217,1,1,0,0,0,218,220,3,4,2,0,219,218,1,0,0,0,
        219,220,1,0,0,0,220,229,1,0,0,0,221,230,3,6,3,0,222,224,3,134,67,
        0,223,222,1,0,0,0,223,224,1,0,0,0,224,227,1,0,0,0,225,228,3,138,
        69,0,226,228,3,196,98,0,227,225,1,0,0,0,227,226,1,0,0,0,228,230,
        1,0,0,0,229,221,1,0,0,0,229,223,1,0,0,0,229,230,1,0,0,0,230,231,
        1,0,0,0,231,232,5,2626,0,0,232,3,1,0,0,0,233,234,3,24,12,0,234,235,
        5,33,0,0,235,5,1,0,0,0,236,237,3,8,4,0,237,238,3,10,5,0,238,316,
        1,0,0,0,239,316,3,12,6,0,240,316,3,14,7,0,241,242,3,16,8,0,242,243,
        3,18,9,0,243,316,1,0,0,0,244,245,3,20,10,0,245,246,3,22,11,0,246,
        316,1,0,0,0,247,250,3,56,28,0,248,251,3,58,29,0,249,251,3,24,12,
        0,250,248,1,0,0,0,250,249,1,0,0,0,251,316,1,0,0,0,252,255,3,60,30,
        0,253,255,3,68,34,0,254,252,1,0,0,0,254,253,1,0,0,0,255,256,1,0,
        0,0,256,257,3,62,31,0,257,316,1,0,0,0,258,259,3,70,35,0,259,260,
        3,72,36,0,260,316,1,0,0,0,261,262,3,80,40,0,262,263,3,82,41,0,263,
        316,1,0,0,0,264,265,3,88,44,0,265,266,3,24,12,0,266,316,1,0,0,0,
        267,270,3,90,45,0,268,271,3,10,5,0,269,271,3,24,12,0,270,268,1,0,
        0,0,270,269,1,0,0,0,271,316,1,0,0,0,272,273,3,92,46,0,273,274,3,
        94,47,0,274,316,1,0,0,0,275,286,5,31,0,0,276,278,3,96,48,0,277,279,
        3,98,49,0,278,277,1,0,0,0,278,279,1,0,0,0,279,280,1,0,0,0,280,281,
        3,100,50,0,281,287,1,0,0,0,282,283,3,110,55,0,283,284,3,112,56,0,
        284,285,3,24,12,0,285,287,1,0,0,0,286,276,1,0,0,0,286,282,1,0,0,
        0,287,288,1,0,0,0,288,289,5,32,0,0,289,316,1,0,0,0,290,291,3,108,
        54,0,291,292,3,58,29,0,292,316,1,0,0,0,293,294,3,114,57,0,294,295,
        3,24,12,0,295,296,3,24,12,0,296,299,1,0,0,0,297,299,3,118,59,0,298,
        293,1,0,0,0,298,297,1,0,0,0,299,301,1,0,0,0,300,302,3,24,12,0,301,
        300,1,0,0,0,302,303,1,0,0,0,303,301,1,0,0,0,303,304,1,0,0,0,304,
        316,1,0,0,0,305,316,3,116,58,0,306,307,3,120,60,0,307,308,3,122,
        61,0,308,316,1,0,0,0,309,310,3,130,65,0,310,311,3,24,12,0,311,316,
        1,0,0,0,312,313,3,132,66,0,313,314,3,10,5,0,314,316,1,0,0,0,315,
        236,1,0,0,0,315,239,1,0,0,0,315,240,1,0,0,0,315,241,1,0,0,0,315,
        244,1,0,0,0,315,247,1,0,0,0,315,254,1,0,0,0,315,258,1,0,0,0,315,
        261,1,0,0,0,315,264,1,0,0,0,315,267,1,0,0,0,315,272,1,0,0,0,315,
        275,1,0,0,0,315,290,1,0,0,0,315,298,1,0,0,0,315,305,1,0,0,0,315,
        306,1,0,0,0,315,309,1,0,0,0,315,312,1,0,0,0,316,7,1,0,0,0,317,318,
        5,2522,0,0,318,9,1,0,0,0,319,320,5,2613,0,0,320,11,1,0,0,0,321,322,
        5,2523,0,0,322,13,1,0,0,0,323,324,5,2524,0,0,324,15,1,0,0,0,325,
        326,5,2525,0,0,326,17,1,0,0,0,327,328,7,0,0,0,328,19,1,0,0,0,329,
        330,7,1,0,0,330,21,1,0,0,0,331,333,3,24,12,0,332,334,3,26,13,0,333,
        332,1,0,0,0,333,334,1,0,0,0,334,336,1,0,0,0,335,337,3,28,14,0,336,
        335,1,0,0,0,336,337,1,0,0,0,337,339,1,0,0,0,338,340,3,30,15,0,339,
        338,1,0,0,0,339,340,1,0,0,0,340,342,1,0,0,0,341,343,3,32,16,0,342,
        341,1,0,0,0,342,343,1,0,0,0,343,345,1,0,0,0,344,346,3,34,17,0,345,
        344,1,0,0,0,345,346,1,0,0,0,346,348,1,0,0,0,347,349,3,36,18,0,348,
        347,1,0,0,0,348,349,1,0,0,0,349,351,1,0,0,0,350,352,3,38,19,0,351,
        350,1,0,0,0,351,352,1,0,0,0,352,354,1,0,0,0,353,355,3,40,20,0,354,
        353,1,0,0,0,354,355,1,0,0,0,355,357,1,0,0,0,356,358,3,42,21,0,357,
        356,1,0,0,0,357,358,1,0,0,0,358,360,1,0,0,0,359,361,3,44,22,0,360,
        359,1,0,0,0,360,361,1,0,0,0,361,364,1,0,0,0,362,365,3,12,6,0,363,
        365,3,14,7,0,364,362,1,0,0,0,364,363,1,0,0,0,364,365,1,0,0,0,365,
        367,1,0,0,0,366,368,3,46,23,0,367,366,1,0,0,0,367,368,1,0,0,0,368,
        371,1,0,0,0,369,372,3,48,24,0,370,372,3,50,25,0,371,369,1,0,0,0,
        371,370,1,0,0,0,371,372,1,0,0,0,372,374,1,0,0,0,373,375,3,52,26,
        0,374,373,1,0,0,0,374,375,1,0,0,0,375,377,1,0,0,0,376,378,3,54,27,
        0,377,376,1,0,0,0,377,378,1,0,0,0,378,23,1,0,0,0,379,380,5,2622,
        0,0,380,25,1,0,0,0,381,382,7,2,0,0,382,27,1,0,0,0,383,384,7,3,0,
        0,384,29,1,0,0,0,385,386,5,2565,0,0,386,387,5,37,0,0,387,388,3,24,
        12,0,388,31,1,0,0,0,389,390,5,2566,0,0,390,391,5,37,0,0,391,392,
        3,24,12,0,392,33,1,0,0,0,393,394,7,4,0,0,394,35,1,0,0,0,395,396,
        7,5,0,0,396,37,1,0,0,0,397,398,7,6,0,0,398,39,1,0,0,0,399,400,7,
        7,0,0,400,41,1,0,0,0,401,402,5,2552,0,0,402,403,5,37,0,0,403,404,
        3,58,29,0,404,43,1,0,0,0,405,406,7,8,0,0,406,407,5,37,0,0,407,408,
        3,24,12,0,408,45,1,0,0,0,409,410,5,2567,0,0,410,47,1,0,0,0,411,412,
        5,2534,0,0,412,413,5,37,0,0,413,414,3,58,29,0,414,49,1,0,0,0,415,
        416,7,9,0,0,416,417,5,37,0,0,417,420,3,58,29,0,418,420,5,2595,0,
        0,419,415,1,0,0,0,419,418,1,0,0,0,420,51,1,0,0,0,421,422,5,2581,
        0,0,422,423,5,37,0,0,423,424,3,58,29,0,424,425,5,33,0,0,425,426,
        3,24,12,0,426,53,1,0,0,0,427,428,5,2594,0,0,428,55,1,0,0,0,429,430,
        5,2534,0,0,430,57,1,0,0,0,431,432,7,10,0,0,432,59,1,0,0,0,433,434,
        5,2535,0,0,434,61,1,0,0,0,435,441,3,24,12,0,436,439,5,33,0,0,437,
        440,3,64,32,0,438,440,3,66,33,0,439,437,1,0,0,0,439,438,1,0,0,0,
        440,442,1,0,0,0,441,436,1,0,0,0,441,442,1,0,0,0,442,447,1,0,0,0,
        443,444,5,27,0,0,444,446,3,62,31,0,445,443,1,0,0,0,446,449,1,0,0,
        0,447,445,1,0,0,0,447,448,1,0,0,0,448,63,1,0,0,0,449,447,1,0,0,0,
        450,452,3,24,12,0,451,450,1,0,0,0,451,452,1,0,0,0,452,453,1,0,0,
        0,453,454,5,2602,0,0,454,457,3,24,12,0,455,456,5,33,0,0,456,458,
        3,58,29,0,457,455,1,0,0,0,457,458,1,0,0,0,458,65,1,0,0,0,459,460,
        5,2605,0,0,460,67,1,0,0,0,461,462,5,2536,0,0,462,69,1,0,0,0,463,
        464,5,2537,0,0,464,71,1,0,0,0,465,468,3,24,12,0,466,467,5,33,0,0,
        467,469,3,74,37,0,468,466,1,0,0,0,468,469,1,0,0,0,469,471,1,0,0,
        0,470,472,3,76,38,0,471,470,1,0,0,0,471,472,1,0,0,0,472,474,1,0,
        0,0,473,475,3,78,39,0,474,473,1,0,0,0,474,475,1,0,0,0,475,477,1,
        0,0,0,476,478,3,192,96,0,477,476,1,0,0,0,477,478,1,0,0,0,478,483,
        1,0,0,0,479,480,5,27,0,0,480,482,3,72,36,0,481,479,1,0,0,0,482,485,
        1,0,0,0,483,481,1,0,0,0,483,484,1,0,0,0,484,73,1,0,0,0,485,483,1,
        0,0,0,486,487,7,11,0,0,487,75,1,0,0,0,488,489,7,12,0,0,489,77,1,
        0,0,0,490,491,7,13,0,0,491,79,1,0,0,0,492,493,5,2538,0,0,493,81,
        1,0,0,0,494,505,3,24,12,0,495,503,3,58,29,0,496,501,5,33,0,0,497,
        502,3,84,42,0,498,502,3,86,43,0,499,502,3,58,29,0,500,502,3,64,32,
        0,501,497,1,0,0,0,501,498,1,0,0,0,501,499,1,0,0,0,501,500,1,0,0,
        0,502,504,1,0,0,0,503,496,1,0,0,0,503,504,1,0,0,0,504,506,1,0,0,
        0,505,495,1,0,0,0,506,507,1,0,0,0,507,505,1,0,0,0,507,508,1,0,0,
        0,508,510,1,0,0,0,509,511,3,58,29,0,510,509,1,0,0,0,510,511,1,0,
        0,0,511,83,1,0,0,0,512,513,5,2539,0,0,513,85,1,0,0,0,514,515,5,2540,
        0,0,515,87,1,0,0,0,516,517,5,2541,0,0,517,89,1,0,0,0,518,519,5,2542,
        0,0,519,91,1,0,0,0,520,521,5,2543,0,0,521,93,1,0,0,0,522,523,7,14,
        0,0,523,95,1,0,0,0,524,525,5,2549,0,0,525,97,1,0,0,0,526,527,7,15,
        0,0,527,99,1,0,0,0,528,532,3,102,51,0,529,532,3,104,52,0,530,532,
        3,106,53,0,531,528,1,0,0,0,531,529,1,0,0,0,531,530,1,0,0,0,532,101,
        1,0,0,0,533,534,7,16,0,0,534,103,1,0,0,0,535,536,5,438,0,0,536,105,
        1,0,0,0,537,538,5,405,0,0,538,107,1,0,0,0,539,540,5,2550,0,0,540,
        109,1,0,0,0,541,542,5,2558,0,0,542,111,1,0,0,0,543,544,7,17,0,0,
        544,113,1,0,0,0,545,546,5,2568,0,0,546,115,1,0,0,0,547,548,5,2569,
        0,0,548,117,1,0,0,0,549,550,5,2570,0,0,550,119,1,0,0,0,551,552,5,
        2571,0,0,552,121,1,0,0,0,553,555,3,24,12,0,554,556,3,24,12,0,555,
        554,1,0,0,0,555,556,1,0,0,0,556,563,1,0,0,0,557,562,3,124,62,0,558,
        562,3,126,63,0,559,562,3,128,64,0,560,562,3,58,29,0,561,557,1,0,
        0,0,561,558,1,0,0,0,561,559,1,0,0,0,561,560,1,0,0,0,562,565,1,0,
        0,0,563,561,1,0,0,0,563,564,1,0,0,0,564,123,1,0,0,0,565,563,1,0,
        0,0,566,567,5,2572,0,0,567,125,1,0,0,0,568,569,5,2573,0,0,569,127,
        1,0,0,0,570,571,5,2574,0,0,571,572,5,37,0,0,572,573,3,58,29,0,573,
        129,1,0,0,0,574,575,5,2582,0,0,575,131,1,0,0,0,576,577,5,2589,0,
        0,577,133,1,0,0,0,578,581,3,136,68,0,579,582,3,192,96,0,580,582,
        3,58,29,0,581,579,1,0,0,0,581,580,1,0,0,0,582,135,1,0,0,0,583,584,
        5,2611,0,0,584,137,1,0,0,0,585,587,3,24,12,0,586,585,1,0,0,0,586,
        587,1,0,0,0,587,614,1,0,0,0,588,589,3,140,70,0,589,594,3,152,76,
        0,590,591,5,27,0,0,591,593,3,152,76,0,592,590,1,0,0,0,593,596,1,
        0,0,0,594,592,1,0,0,0,594,595,1,0,0,0,595,615,1,0,0,0,596,594,1,
        0,0,0,597,598,3,146,73,0,598,599,3,58,29,0,599,615,1,0,0,0,600,601,
        3,148,74,0,601,606,3,154,77,0,602,603,5,27,0,0,603,605,3,154,77,
        0,604,602,1,0,0,0,605,608,1,0,0,0,606,604,1,0,0,0,606,607,1,0,0,
        0,607,615,1,0,0,0,608,606,1,0,0,0,609,612,3,194,97,0,610,613,3,58,
        29,0,611,613,3,192,96,0,612,610,1,0,0,0,612,611,1,0,0,0,613,615,
        1,0,0,0,614,588,1,0,0,0,614,597,1,0,0,0,614,600,1,0,0,0,614,609,
        1,0,0,0,615,139,1,0,0,0,616,617,7,18,0,0,617,141,1,0,0,0,618,619,
        5,2612,0,0,619,143,1,0,0,0,620,621,5,28,0,0,621,145,1,0,0,0,622,
        623,7,19,0,0,623,147,1,0,0,0,624,625,5,17,0,0,625,149,1,0,0,0,626,
        627,5,2618,0,0,627,151,1,0,0,0,628,635,3,154,77,0,629,630,3,156,
        78,0,630,631,3,152,76,0,631,635,1,0,0,0,632,635,3,158,79,0,633,635,
        3,206,103,0,634,628,1,0,0,0,634,629,1,0,0,0,634,632,1,0,0,0,634,
        633,1,0,0,0,635,153,1,0,0,0,636,643,3,58,29,0,637,643,3,142,71,0,
        638,643,3,150,75,0,639,643,3,24,12,0,640,643,3,144,72,0,641,643,
        3,192,96,0,642,636,1,0,0,0,642,637,1,0,0,0,642,638,1,0,0,0,642,639,
        1,0,0,0,642,640,1,0,0,0,642,641,1,0,0,0,643,155,1,0,0,0,644,645,
        7,20,0,0,645,157,1,0,0,0,646,656,3,160,80,0,647,648,5,58,0,0,648,
        656,3,162,81,0,649,651,3,156,78,0,650,652,5,58,0,0,651,650,1,0,0,
        0,651,652,1,0,0,0,652,653,1,0,0,0,653,654,3,162,81,0,654,656,1,0,
        0,0,655,646,1,0,0,0,655,647,1,0,0,0,655,649,1,0,0,0,656,159,1,0,
        0,0,657,658,3,192,96,0,658,660,5,26,0,0,659,661,3,156,78,0,660,659,
        1,0,0,0,660,661,1,0,0,0,661,663,1,0,0,0,662,664,5,58,0,0,663,662,
        1,0,0,0,663,664,1,0,0,0,664,665,1,0,0,0,665,666,3,162,81,0,666,161,
        1,0,0,0,667,668,5,29,0,0,668,673,3,152,76,0,669,670,5,27,0,0,670,
        672,3,152,76,0,671,669,1,0,0,0,672,675,1,0,0,0,673,671,1,0,0,0,673,
        674,1,0,0,0,674,676,1,0,0,0,675,673,1,0,0,0,676,677,5,30,0,0,677,
        163,1,0,0,0,678,679,3,166,83,0,679,680,3,168,84,0,680,686,1,0,0,
        0,681,682,5,29,0,0,682,683,3,192,96,0,683,684,5,30,0,0,684,686,1,
        0,0,0,685,678,1,0,0,0,685,681,1,0,0,0,686,165,1,0,0,0,687,688,7,
        21,0,0,688,167,1,0,0,0,689,703,3,164,82,0,690,703,3,58,29,0,691,
        703,3,202,101,0,692,693,3,202,101,0,693,694,5,33,0,0,694,696,1,0,
        0,0,695,692,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,703,3,24,
        12,0,698,703,3,150,75,0,699,703,3,142,71,0,700,703,5,62,0,0,701,
        703,5,63,0,0,702,689,1,0,0,0,702,690,1,0,0,0,702,691,1,0,0,0,702,
        695,1,0,0,0,702,698,1,0,0,0,702,699,1,0,0,0,702,700,1,0,0,0,702,
        701,1,0,0,0,703,169,1,0,0,0,704,709,3,168,84,0,705,706,7,22,0,0,
        706,708,3,168,84,0,707,705,1,0,0,0,708,711,1,0,0,0,709,707,1,0,0,
        0,709,710,1,0,0,0,710,171,1,0,0,0,711,709,1,0,0,0,712,717,3,170,
        85,0,713,714,7,23,0,0,714,716,3,170,85,0,715,713,1,0,0,0,716,719,
        1,0,0,0,717,715,1,0,0,0,717,718,1,0,0,0,718,173,1,0,0,0,719,717,
        1,0,0,0,720,725,3,172,86,0,721,722,7,24,0,0,722,724,3,172,86,0,723,
        721,1,0,0,0,724,727,1,0,0,0,725,723,1,0,0,0,725,726,1,0,0,0,726,
        175,1,0,0,0,727,725,1,0,0,0,728,733,3,174,87,0,729,730,7,25,0,0,
        730,732,3,174,87,0,731,729,1,0,0,0,732,735,1,0,0,0,733,731,1,0,0,
        0,733,734,1,0,0,0,734,177,1,0,0,0,735,733,1,0,0,0,736,741,3,176,
        88,0,737,738,7,26,0,0,738,740,3,176,88,0,739,737,1,0,0,0,740,743,
        1,0,0,0,741,739,1,0,0,0,741,742,1,0,0,0,742,179,1,0,0,0,743,741,
        1,0,0,0,744,749,3,178,89,0,745,746,5,48,0,0,746,748,3,178,89,0,747,
        745,1,0,0,0,748,751,1,0,0,0,749,747,1,0,0,0,749,750,1,0,0,0,750,
        181,1,0,0,0,751,749,1,0,0,0,752,757,3,180,90,0,753,754,5,47,0,0,
        754,756,3,180,90,0,755,753,1,0,0,0,756,759,1,0,0,0,757,755,1,0,0,
        0,757,758,1,0,0,0,758,183,1,0,0,0,759,757,1,0,0,0,760,765,3,182,
        91,0,761,762,5,46,0,0,762,764,3,182,91,0,763,761,1,0,0,0,764,767,
        1,0,0,0,765,763,1,0,0,0,765,766,1,0,0,0,766,185,1,0,0,0,767,765,
        1,0,0,0,768,773,3,184,92,0,769,770,5,36,0,0,770,772,3,184,92,0,771,
        769,1,0,0,0,772,775,1,0,0,0,773,771,1,0,0,0,773,774,1,0,0,0,774,
        187,1,0,0,0,775,773,1,0,0,0,776,781,3,186,93,0,777,778,5,34,0,0,
        778,780,3,186,93,0,779,777,1,0,0,0,780,783,1,0,0,0,781,779,1,0,0,
        0,781,782,1,0,0,0,782,189,1,0,0,0,783,781,1,0,0,0,784,790,3,188,
        94,0,785,786,5,28,0,0,786,787,3,58,29,0,787,788,5,33,0,0,788,789,
        3,190,95,0,789,791,1,0,0,0,790,785,1,0,0,0,790,791,1,0,0,0,791,191,
        1,0,0,0,792,793,3,190,95,0,793,193,1,0,0,0,794,795,5,142,0,0,795,
        195,1,0,0,0,796,798,3,198,99,0,797,799,3,200,100,0,798,797,1,0,0,
        0,798,799,1,0,0,0,799,804,1,0,0,0,800,801,5,27,0,0,801,803,3,200,
        100,0,802,800,1,0,0,0,803,806,1,0,0,0,804,802,1,0,0,0,804,805,1,
        0,0,0,805,809,1,0,0,0,806,804,1,0,0,0,807,809,3,206,103,0,808,796,
        1,0,0,0,808,807,1,0,0,0,809,197,1,0,0,0,810,811,7,27,0,0,811,199,
        1,0,0,0,812,814,3,156,78,0,813,812,1,0,0,0,813,814,1,0,0,0,814,818,
        1,0,0,0,815,816,3,202,101,0,816,817,5,33,0,0,817,819,1,0,0,0,818,
        815,1,0,0,0,818,819,1,0,0,0,819,826,1,0,0,0,820,827,3,202,101,0,
        821,827,3,24,12,0,822,823,5,31,0,0,823,824,3,192,96,0,824,825,5,
        32,0,0,825,827,1,0,0,0,826,820,1,0,0,0,826,821,1,0,0,0,826,822,1,
        0,0,0,827,852,1,0,0,0,828,830,3,204,102,0,829,828,1,0,0,0,829,830,
        1,0,0,0,830,831,1,0,0,0,831,833,3,156,78,0,832,829,1,0,0,0,832,833,
        1,0,0,0,833,848,1,0,0,0,834,849,3,150,75,0,835,849,3,142,71,0,836,
        849,3,58,29,0,837,838,5,31,0,0,838,843,3,192,96,0,839,840,5,27,0,
        0,840,842,3,192,96,0,841,839,1,0,0,0,842,845,1,0,0,0,843,841,1,0,
        0,0,843,844,1,0,0,0,844,846,1,0,0,0,845,843,1,0,0,0,846,847,5,32,
        0,0,847,849,1,0,0,0,848,834,1,0,0,0,848,835,1,0,0,0,848,836,1,0,
        0,0,848,837,1,0,0,0,849,852,1,0,0,0,850,852,3,192,96,0,851,813,1,
        0,0,0,851,832,1,0,0,0,851,850,1,0,0,0,852,201,1,0,0,0,853,854,7,
        28,0,0,854,203,1,0,0,0,855,856,5,2610,0,0,856,205,1,0,0,0,857,880,
        3,24,12,0,858,860,3,208,104,0,859,858,1,0,0,0,859,860,1,0,0,0,860,
        865,1,0,0,0,861,862,5,27,0,0,862,864,3,208,104,0,863,861,1,0,0,0,
        864,867,1,0,0,0,865,863,1,0,0,0,865,866,1,0,0,0,866,881,1,0,0,0,
        867,865,1,0,0,0,868,870,5,29,0,0,869,871,3,208,104,0,870,869,1,0,
        0,0,870,871,1,0,0,0,871,876,1,0,0,0,872,873,5,27,0,0,873,875,3,208,
        104,0,874,872,1,0,0,0,875,878,1,0,0,0,876,874,1,0,0,0,876,877,1,
        0,0,0,877,879,1,0,0,0,878,876,1,0,0,0,879,881,5,30,0,0,880,859,1,
        0,0,0,880,868,1,0,0,0,881,207,1,0,0,0,882,887,3,150,75,0,883,887,
        3,24,12,0,884,887,3,58,29,0,885,887,3,142,71,0,886,882,1,0,0,0,886,
        883,1,0,0,0,886,884,1,0,0,0,886,885,1,0,0,0,887,209,1,0,0,0,91,213,
        219,223,227,229,250,254,270,278,286,298,303,315,333,336,339,342,
        345,348,351,354,357,360,364,367,371,374,377,419,439,441,447,451,
        457,468,471,474,477,483,501,503,507,510,531,555,561,563,581,586,
        594,606,612,614,634,642,651,655,660,663,673,685,695,702,709,717,
        725,733,741,749,757,765,773,781,790,798,804,808,813,818,826,829,
        832,843,848,851,859,865,870,876,880,886
    ]

class nasm_x86_64_Parser ( Parser ):

    grammarFileName = "nasm_x86_64_Parser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'db'", "'dw'", "'dd'", "'dq'", "'dt'", 
                     "'do'", "'dy'", "'dz'", "'resb'", "'resw'", "'resd'", 
                     "'resq'", "'rest'", "'reso'", "'resy'", "'resz'", "'incbin'", 
                     "'byte'", "'word'", "'dword'", "'qword'", "'tword'", 
                     "'oword'", "'yword'", "'zword'", "'dup'", "','", "'?'", 
                     "'('", "')'", "'['", "']'", "':'", "'||'", "'^^'", 
                     "'&&'", "'='", "'=='", "'!='", "'<>'", "'<'", "'<='", 
                     "'>'", "'>='", "'<=>'", "'|'", "'^'", "'&'", "'<<'", 
                     "'>>'", "'<<<'", "'>>>'", "'+'", "'-'", "'*'", "'/'", 
                     "'//'", "'%'", "'%%'", "'~'", "'!'", "'$'", "'$$'", 
                     "'aaa'", "'aad'", "'aam'", "'aas'", "'adc'", "'add'", 
                     "'and'", "'arpl'", "'bb0_reset'", "'bb1_reset'", "'bound'", 
                     "'bsf'", "'bsr'", "'bswap'", "'bt'", "'btc'", "'btr'", 
                     "'bts'", "'call'", "'cbw'", "'cdq'", "'cdqe'", "'clc'", 
                     "'cld'", "'cli'", "'clts'", "'cmc'", "'cmova'", "'cmovae'", 
                     "'cmovb'", "'cmovbe'", "'cmovc'", "'cmove'", "'cmovg'", 
                     "'cmovge'", "'cmovl'", "'cmovle'", "'cmovna'", "'cmovnae'", 
                     "'cmovnb'", "'cmovnbe'", "'cmovnc'", "'cmovne'", "'cmovng'", 
                     "'cmovnge'", "'cmovnl'", "'cmovno'", "'cmovnp'", "'cmovns'", 
                     "'cmovnz'", "'cmovo'", "'cmovp'", "'cmovpe'", "'cmovpo'", 
                     "'cmovs'", "'cmovz'", "'cmp'", "'cmpsb'", "'cmpsd'", 
                     "'cmpsq'", "'cmpsw'", "'cmpxchg'", "'cmpxchg16b'", 
                     "'cmpxchg486'", "'cmpxchg8b'", "'cpu_read'", "'cpu_write'", 
                     "'cpuid'", "'cqo'", "'cwd'", "'cwde'", "'daa'", "'das'", 
                     "'dec'", "'div'", "'dmint'", "'emms'", "'enter'", "'equ'", 
                     "'f2xm1'", "'fabs'", "'fadd'", "'faddp'", "'fbld'", 
                     "'fbstp'", "'fchs'", "'fclex'", "'fcmovb'", "'fcmovbe'", 
                     "'fcmove'", "'fcmovnb'", "'fcmovnbe'", "'fcmovne'", 
                     "'fcmovnu'", "'fcmovu'", "'fcom'", "'fcomi'", "'fcomip'", 
                     "'fcomp'", "'fcompp'", "'fcos'", "'fdecstp'", "'fdisi'", 
                     "'fdiv'", "'fdivp'", "'fdivr'", "'fdivrp'", "'femms'", 
                     "'feni'", "'ffree'", "'ffreep'", "'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'", 
                     "'fndisi'", "'fneni'", "'fninit'", "'fnop'", "'fnsave'", 
                     "'fnstcw'", "'fnstenv'", "'fnstsw'", "'fpatan'", "'fprem'", 
                     "'fprem1'", "'fptan'", "'frndint'", "'frstor'", "'fsave'", 
                     "'fscale'", "'fsetpm'", "'fsin'", "'fsincos'", "'fsqrt'", 
                     "'fst'", "'fstcw'", "'fstenv'", "'fstp'", "'fstsw'", 
                     "'fsub'", "'fsubp'", "'fsubr'", "'fsubrp'", "'ftst'", 
                     "'fucom'", "'fucomi'", "'fucomip'", "'fucomp'", "'fucompp'", 
                     "'fwait'", "'fxam'", "'fxch'", "'fxtract'", "'fyl2x'", 
                     "'fyl2xp1'", "'hlt'", "'ibts'", "'icebp'", "'idiv'", 
                     "'imul'", "'in'", "'inc'", "'insb'", "'insd'", "'insw'", 
                     "'int'", "'int01'", "'int03'", "'int1'", "'int3'", 
                     "'into'", "'invd'", "'invlpg'", "'invlpga'", "'invpcid'", 
                     "'iret'", "'iretd'", "'iretq'", "'iretw'", "'ja'", 
                     "'jae'", "'jb'", "'jbe'", "'jc'", "'jcxz'", "'je'", 
                     "'jecxz'", "'jg'", "'jge'", "'jl'", "'jle'", "'jmp'", 
                     "'jmpe'", "'jna'", "'jnae'", "'jnb'", "'jnbe'", "'jnc'", 
                     "'jne'", "'jng'", "'jnge'", "'jnl'", "'jnle'", "'jno'", 
                     "'jnp'", "'jns'", "'jnz'", "'jo'", "'jp'", "'jpe'", 
                     "'jpo'", "'jrcxz'", "'js'", "'jz'", "'lahf'", "'lar'", 
                     "'lds'", "'lea'", "'leave'", "'les'", "'lfence'", "'lfs'", 
                     "'lgdt'", "'lgs'", "'lidt'", "'lldt'", "'lmsw'", "'loadall'", 
                     "'loadall286'", "'lodsb'", "'lodsd'", "'lodsq'", "'lodsw'", 
                     "'loop'", "'loope'", "'loopne'", "'loopnz'", "'loopz'", 
                     "'lsl'", "'lss'", "'ltr'", "'mfence'", "'monitor'", 
                     "'monitorx'", "'mov'", "'movd'", "'movq'", "'movsb'", 
                     "'movsd'", "'movsq'", "'movsw'", "'movsx'", "'movsxd'", 
                     "'movzx'", "'mul'", "'mwait'", "'mwaitx'", "'neg'", 
                     "'nop'", "'not'", "'or'", "'out'", "'outsb'", "'outsd'", 
                     "'outsw'", "'packssdw'", "'packsswb'", "'packuswb'", 
                     "'paddb'", "'paddd'", "'paddsb'", "'paddsiw'", "'paddsw'", 
                     "'paddusb'", "'paddusw'", "'paddw'", "'pand'", "'pandn'", 
                     "'pause'", "'paveb'", "'pavgusb'", "'pcmpeqb'", "'pcmpeqd'", 
                     "'pcmpeqw'", "'pcmpgtb'", "'pcmpgtd'", "'pcmpgtw'", 
                     "'pdistib'", "'pf2id'", "'pfacc'", "'pfadd'", "'pfcmpeq'", 
                     "'pfcmpge'", "'pfcmpgt'", "'pfmax'", "'pfmin'", "'pfmul'", 
                     "'pfrcp'", "'pfrcpit1'", "'pfrcpit2'", "'pfrsqit1'", 
                     "'pfrsqrt'", "'pfsub'", "'pfsubr'", "'pi2fd'", "'pmachriw'", 
                     "'pmaddwd'", "'pmagw'", "'pmulhriw'", "'pmulhrwa'", 
                     "'pmulhrwc'", "'pmulhw'", "'pmullw'", "'pmvgezb'", 
                     "'pmvlzb'", "'pmvnzb'", "'pmvzb'", "'pop'", "'popa'", 
                     "'popad'", "'popaw'", "'popf'", "'popfd'", "'popfq'", 
                     "'popfw'", "'por'", "'prefetch'", "'prefetchw'", "'pslld'", 
                     "'psllq'", "'psllw'", "'psrad'", "'psraw'", "'psrld'", 
                     "'psrlq'", "'psrlw'", "'psubb'", "'psubd'", "'psubsb'", 
                     "'psubsiw'", "'psubsw'", "'psubusb'", "'psubusw'", 
                     "'psubw'", "'punpckhbw'", "'punpckhdq'", "'punpckhwd'", 
                     "'punpcklbw'", "'punpckldq'", "'punpcklwd'", "'push'", 
                     "'pusha'", "'pushad'", "'pushaw'", "'pushf'", "'pushfd'", 
                     "'pushfq'", "'pushfw'", "'pxor'", "'rcl'", "'rcr'", 
                     "'rdm'", "'rdmsr'", "'rdpmc'", "'rdshr'", "'rdtsc'", 
                     "'rdtscp'", "'ret'", "'retd'", "'retf'", "'retfd'", 
                     "'retfq'", "'retfw'", "'retn'", "'retnd'", "'retnq'", 
                     "'retnw'", "'retq'", "'retw'", "'rol'", "'ror'", "'rsdc'", 
                     "'rsldt'", "'rsm'", "'rsts'", "'sahf'", "'sal'", "'salc'", 
                     "'sar'", "'sbb'", "'scasb'", "'scasd'", "'scasq'", 
                     "'scasw'", "'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'", "'shl'", "'shld'", 
                     "'shr'", "'shrd'", "'sidt'", "'skinit'", "'sldt'", 
                     "'smi'", "'smint'", "'smintold'", "'smsw'", "'stc'", 
                     "'std'", "'sti'", "'stosb'", "'stosd'", "'stosq'", 
                     "'stosw'", "'str'", "'sub'", "'svdc'", "'svldt'", "'svts'", 
                     "'swapgs'", "'syscall'", "'sysenter'", "'sysexit'", 
                     "'sysret'", "'test'", "'ud0'", "'ud1'", "'ud2'", "'ud2a'", 
                     "'ud2b'", "'umov'", "'verr'", "'verw'", "'wbinvd'", 
                     "'wrmsr'", "'wrshr'", "'xadd'", "'xbts'", "'xchg'", 
                     "'xlat'", "'xlatb'", "'xor'", "'al'", "'ah'", "'ax'", 
                     "'eax'", "'rax'", "'bl'", "'bh'", "'bx'", "'ebx'", 
                     "'rbx'", "'cl'", "'ch'", "'cx'", "'ecx'", "'rcx'", 
                     "'dl'", "'dh'", "'dx'", "'edx'", "'rdx'", "'spl'", 
                     "'sp'", "'esp'", "'rsp'", "'bpl'", "'bp'", "'ebp'", 
                     "'rbp'", "'sil'", "'si'", "'esi'", "'rsi'", "'dil'", 
                     "'di'", "'edi'", "'rdi'", "'r8b'", "'r9b'", "'r10b'", 
                     "'r11b'", "'r12b'", "'r13b'", "'r14b'", "'r15b'", "'r8w'", 
                     "'r9w'", "'r10w'", "'r11w'", "'r12w'", "'r13w'", "'r14w'", 
                     "'r15w'", "'r8d'", "'r9d'", "'r10d'", "'r11d'", "'r12d'", 
                     "'r13d'", "'r14d'", "'r15d'", "'r8'", "'r9'", "'r10'", 
                     "'r11'", "'r12'", "'r13'", "'r14'", "'r15'", "'ip'", 
                     "'eip'", "'rip'", "'es'", "'cs'", "'ss'", "'ds'", "'fs'", 
                     "'gs'", "'segr6'", "'segr7'", "'cr0'", "'cr1'", "'cr2'", 
                     "'cr3'", "'cr4'", "'cr5'", "'cr6'", "'cr7'", "'cr8'", 
                     "'cr9'", "'cr10'", "'cr11'", "'cr12'", "'cr13'", "'cr14'", 
                     "'cr15'", "'dr0'", "'dr1'", "'dr2'", "'dr3'", "'dr4'", 
                     "'dr5'", "'dr6'", "'dr7'", "'dr8'", "'dr9'", "'dr10'", 
                     "'dr11'", "'dr12'", "'dr13'", "'dr14'", "'dr15'", "'tr0'", 
                     "'tr1'", "'tr2'", "'tr3'", "'tr4'", "'tr5'", "'tr6'", 
                     "'tr7'", "'st0'", "'st1'", "'st2'", "'st3'", "'st4'", 
                     "'st5'", "'st6'", "'st7'", "'mm0'", "'mm1'", "'mm2'", 
                     "'mm3'", "'mm4'", "'mm5'", "'mm6'", "'mm7'", "'xmm0'", 
                     "'xmm1'", "'xmm2'", "'xmm3'", "'xmm4'", "'xmm5'", "'xmm6'", 
                     "'xmm7'", "'xmm8'", "'xmm9'", "'xmm10'", "'xmm11'", 
                     "'xmm12'", "'xmm13'", "'xmm14'", "'xmm15'", "'xmm16'", 
                     "'xmm17'", "'xmm18'", "'xmm19'", "'xmm20'", "'xmm21'", 
                     "'xmm22'", "'xmm23'", "'xmm24'", "'xmm25'", "'xmm26'", 
                     "'xmm27'", "'xmm28'", "'xmm29'", "'xmm30'", "'xmm31'", 
                     "'ymm0'", "'ymm1'", "'ymm2'", "'ymm3'", "'ymm4'", "'ymm5'", 
                     "'ymm6'", "'ymm7'", "'ymm8'", "'ymm9'", "'ymm10'", 
                     "'ymm11'", "'ymm12'", "'ymm13'", "'ymm14'", "'ymm15'", 
                     "'ymm16'", "'ymm17'", "'ymm18'", "'ymm19'", "'ymm20'", 
                     "'ymm21'", "'ymm22'", "'ymm23'", "'ymm24'", "'ymm25'", 
                     "'ymm26'", "'ymm27'", "'ymm28'", "'ymm29'", "'ymm30'", 
                     "'ymm31'", "'zmm0'", "'zmm1'", "'zmm2'", "'zmm3'", 
                     "'zmm4'", "'zmm5'", "'zmm6'", "'zmm7'", "'zmm8'", "'zmm9'", 
                     "'zmm10'", "'zmm11'", "'zmm12'", "'zmm13'", "'zmm14'", 
                     "'zmm15'", "'zmm16'", "'zmm17'", "'zmm18'", "'zmm19'", 
                     "'zmm20'", "'zmm21'", "'zmm22'", "'zmm23'", "'zmm24'", 
                     "'zmm25'", "'zmm26'", "'zmm27'", "'zmm28'", "'zmm29'", 
                     "'zmm30'", "'zmm31'", "'tmm0'", "'tmm1'", "'tmm2'", 
                     "'tmm3'", "'tmm4'", "'tmm5'", "'tmm6'", "'tmm7'", "'k0'", 
                     "'k1'", "'k2'", "'k3'", "'k4'", "'k5'", "'k6'", "'k7'", 
                     "'bnd0'", "'bnd1'", "'bnd2'", "'bnd3'", "'aadd'", "'aand'", 
                     "'adcx'", "'addpd'", "'addps'", "'addsd'", "'addss'", 
                     "'addsubpd'", "'addsubps'", "'adox'", "'aesdec'", "'aesdeclast'", 
                     "'aesenc'", "'aesenclast'", "'aesimc'", "'aeskeygenassist'", 
                     "'andn'", "'andnpd'", "'andnps'", "'andpd'", "'andps'", 
                     "'axor'", "'bextr'", "'blcfill'", "'blci'", "'blcic'", 
                     "'blcmsk'", "'blcs'", "'blendpd'", "'blendps'", "'blendvpd'", 
                     "'blendvps'", "'blsfill'", "'blsi'", "'blsic'", "'blsmsk'", 
                     "'blsr'", "'bndcl'", "'bndcn'", "'bndcu'", "'bndldx'", 
                     "'bndmk'", "'bndmov'", "'bndstx'", "'bzhi'", "'clac'", 
                     "'cldemote'", "'clflush'", "'clflushopt'", "'clgi'", 
                     "'clrssbsy'", "'clui'", "'clwb'", "'clzero'", "'cmpeqpd'", 
                     "'cmpeqps'", "'cmpeqsd'", "'cmpeqss'", "'cmplepd'", 
                     "'cmpleps'", "'cmplesd'", "'cmpless'", "'cmpltpd'", 
                     "'cmpltps'", "'cmpltsd'", "'cmpltss'", "'cmpneqpd'", 
                     "'cmpneqps'", "'cmpneqsd'", "'cmpneqss'", "'cmpnlepd'", 
                     "'cmpnleps'", "'cmpnlesd'", "'cmpnless'", "'cmpnltpd'", 
                     "'cmpnltps'", "'cmpnltsd'", "'cmpnltss'", "'cmpnpxadd'", 
                     "'cmpnsxadd'", "'cmpnzxadd'", "'cmpordpd'", "'cmpordps'", 
                     "'cmpordsd'", "'cmpordss'", "'cmpoxadd'", "'cmppd'", 
                     "'cmpps'", "'cmppxadd'", "'cmpss'", "'cmpsxadd'", "'cmpunordpd'", 
                     "'cmpunordps'", "'cmpunordsd'", "'cmpunordss'", "'cmpzxadd'", 
                     "'comisd'", "'comiss'", "'crc32'", "'cvtdq2pd'", "'cvtdq2ps'", 
                     "'cvtpd2dq'", "'cvtpd2pi'", "'cvtpd2ps'", "'cvtpi2pd'", 
                     "'cvtpi2ps'", "'cvtps2dq'", "'cvtps2pd'", "'cvtps2pi'", 
                     "'cvtsd2si'", "'cvtsd2ss'", "'cvtsi2sd'", "'cvtsi2ss'", 
                     "'cvtss2sd'", "'cvtss2si'", "'cvttpd2dq'", "'cvttpd2pi'", 
                     "'cvttps2dq'", "'cvttps2pi'", "'cvttsd2si'", "'cvttss2si'", 
                     "'divpd'", "'divps'", "'divsd'", "'divss'", "'dppd'", 
                     "'dpps'", "'encls'", "'enclu'", "'enclv'", "'endbr32'", 
                     "'endbr64'", "'enqcmd'", "'enqcmds'", "'extractps'", 
                     "'extrq'", "'fxrstor'", "'fxrstor64'", "'fxsave'", 
                     "'fxsave64'", "'getsec'", "'gf2p8affineinvqb'", "'gf2p8affineqb'", 
                     "'gf2p8mulb'", "'haddpd'", "'haddps'", "'hint_nop0'", 
                     "'hint_nop1'", "'hint_nop10'", "'hint_nop11'", "'hint_nop12'", 
                     "'hint_nop13'", "'hint_nop14'", "'hint_nop15'", "'hint_nop16'", 
                     "'hint_nop17'", "'hint_nop18'", "'hint_nop19'", "'hint_nop2'", 
                     "'hint_nop20'", "'hint_nop21'", "'hint_nop22'", "'hint_nop23'", 
                     "'hint_nop24'", "'hint_nop25'", "'hint_nop26'", "'hint_nop27'", 
                     "'hint_nop28'", "'hint_nop29'", "'hint_nop3'", "'hint_nop30'", 
                     "'hint_nop31'", "'hint_nop32'", "'hint_nop33'", "'hint_nop34'", 
                     "'hint_nop35'", "'hint_nop36'", "'hint_nop37'", "'hint_nop38'", 
                     "'hint_nop39'", "'hint_nop4'", "'hint_nop40'", "'hint_nop41'", 
                     "'hint_nop42'", "'hint_nop43'", "'hint_nop44'", "'hint_nop45'", 
                     "'hint_nop46'", "'hint_nop47'", "'hint_nop48'", "'hint_nop49'", 
                     "'hint_nop5'", "'hint_nop50'", "'hint_nop51'", "'hint_nop52'", 
                     "'hint_nop53'", "'hint_nop54'", "'hint_nop55'", "'hint_nop56'", 
                     "'hint_nop57'", "'hint_nop58'", "'hint_nop59'", "'hint_nop6'", 
                     "'hint_nop60'", "'hint_nop61'", "'hint_nop62'", "'hint_nop63'", 
                     "'hint_nop7'", "'hint_nop8'", "'hint_nop9'", "'hreset'", 
                     "'hsubpd'", "'hsubps'", "'incsspd'", "'incsspq'", "'insertps'", 
                     "'insertq'", "'invept'", "'invvpid'", "'kadd'", "'kaddb'", 
                     "'kaddd'", "'kaddq'", "'kaddw'", "'kand'", "'kandb'", 
                     "'kandd'", "'kandn'", "'kandnb'", "'kandnd'", "'kandnq'", 
                     "'kandnw'", "'kandq'", "'kandw'", "'kmov'", "'kmovb'", 
                     "'kmovd'", "'kmovq'", "'kmovw'", "'knot'", "'knotb'", 
                     "'knotd'", "'knotq'", "'knotw'", "'kor'", "'korb'", 
                     "'kord'", "'korq'", "'kortest'", "'kortestb'", "'kortestd'", 
                     "'kortestq'", "'kortestw'", "'korw'", "'kshiftl'", 
                     "'kshiftlb'", "'kshiftld'", "'kshiftlq'", "'kshiftlw'", 
                     "'kshiftr'", "'kshiftrb'", "'kshiftrd'", "'kshiftrq'", 
                     "'kshiftrw'", "'ktest'", "'ktestb'", "'ktestd'", "'ktestq'", 
                     "'ktestw'", "'kunpck'", "'kunpckbw'", "'kunpckdq'", 
                     "'kunpckwd'", "'kxnor'", "'kxnorb'", "'kxnord'", "'kxnorq'", 
                     "'kxnorw'", "'kxor'", "'kxorb'", "'kxord'", "'kxorq'", 
                     "'kxorw'", "'lddqu'", "'ldmxcsr'", "'ldtilecfg'", "'llwpcb'", 
                     "'lwpins'", "'lwpval'", "'lzcnt'", "'maskmovdqu'", 
                     "'maskmovq'", "'maxpd'", "'maxps'", "'maxsd'", "'maxss'", 
                     "'minpd'", "'minps'", "'minsd'", "'minss'", "'montmul'", 
                     "'movapd'", "'movaps'", "'movbe'", "'movddup'", "'movdir64b'", 
                     "'movdiri'", "'movdq2q'", "'movdqa'", "'movdqu'", "'movhlps'", 
                     "'movhpd'", "'movhps'", "'movlhps'", "'movlpd'", "'movlps'", 
                     "'movmskpd'", "'movmskps'", "'movntdq'", "'movntdqa'", 
                     "'movnti'", "'movntpd'", "'movntps'", "'movntq'", "'movntsd'", 
                     "'movntss'", "'movq2dq'", "'movshdup'", "'movsldup'", 
                     "'movss'", "'movupd'", "'movups'", "'mpsadbw'", "'mulpd'", 
                     "'mulps'", "'mulsd'", "'mulss'", "'mulx'", "'orpd'", 
                     "'orps'", "'pabsb'", "'pabsd'", "'pabsw'", "'packusdw'", 
                     "'paddq'", "'palignr'", "'pavgb'", "'pavgw'", "'pblendvb'", 
                     "'pblendw'", "'pclmulhqhqdq'", "'pclmulhqlqdq'", "'pclmullqhqdq'", 
                     "'pclmullqlqdq'", "'pclmulqdq'", "'pcmpeqq'", "'pcmpestri'", 
                     "'pcmpestrm'", "'pcmpgtq'", "'pcmpistri'", "'pcmpistrm'", 
                     "'pcommit'", "'pconfig'", "'pdep'", "'pext'", "'pextrb'", 
                     "'pextrd'", "'pextrq'", "'pextrw'", "'pf2iw'", "'pfnacc'", 
                     "'pfpnacc'", "'pfrcpv'", "'pfrsqrtv'", "'phaddd'", 
                     "'phaddsw'", "'phaddw'", "'phminposuw'", "'phsubd'", 
                     "'phsubsw'", "'phsubw'", "'pi2fw'", "'pinsrb'", "'pinsrd'", 
                     "'pinsrq'", "'pinsrw'", "'pmaddubsw'", "'pmaxsb'", 
                     "'pmaxsd'", "'pmaxsw'", "'pmaxub'", "'pmaxud'", "'pmaxuw'", 
                     "'pminsb'", "'pminsd'", "'pminsw'", "'pminub'", "'pminud'", 
                     "'pminuw'", "'pmovmskb'", "'pmovsxbd'", "'pmovsxbq'", 
                     "'pmovsxbw'", "'pmovsxdq'", "'pmovsxwd'", "'pmovsxwq'", 
                     "'pmovzxbd'", "'pmovzxbq'", "'pmovzxbw'", "'pmovzxdq'", 
                     "'pmovzxwd'", "'pmovzxwq'", "'pmuldq'", "'pmulhrsw'", 
                     "'pmulhuw'", "'pmulld'", "'pmuludq'", "'popcnt'", "'prefetchit0'", 
                     "'prefetchit1'", "'prefetchnta'", "'prefetcht0'", "'prefetcht1'", 
                     "'prefetcht2'", "'prefetchwt1'", "'psadbw'", "'pshufb'", 
                     "'pshufd'", "'pshufhw'", "'pshuflw'", "'pshufw'", "'psignb'", 
                     "'psignd'", "'psignw'", "'pslldq'", "'psrldq'", "'psubq'", 
                     "'pswapd'", "'ptest'", "'ptwrite'", "'punpckhqdq'", 
                     "'punpcklqdq'", "'pvalidate'", "'rcpps'", "'rcpss'", 
                     "'rdfsbase'", "'rdgsbase'", "'rdmsrlist'", "'rdpid'", 
                     "'rdpkru'", "'rdrand'", "'rdseed'", "'rdsspd'", "'rdsspq'", 
                     "'rmpadjust'", "'rorx'", "'roundpd'", "'roundps'", 
                     "'roundsd'", "'roundss'", "'rsqrtps'", "'rsqrtss'", 
                     "'rstorssp'", "'sarx'", "'saveprevssp'", "'senduipi'", 
                     "'serialize'", "'setssbsy'", "'sha1msg1'", "'sha1msg2'", 
                     "'sha1nexte'", "'sha1rnds4'", "'sha256msg1'", "'sha256msg2'", 
                     "'sha256rnds2'", "'shlx'", "'shrx'", "'shufpd'", "'shufps'", 
                     "'slwpcb'", "'sqrtpd'", "'sqrtps'", "'sqrtsd'", "'sqrtss'", 
                     "'stac'", "'stgi'", "'stmxcsr'", "'sttilecfg'", "'stui'", 
                     "'subpd'", "'subps'", "'subsd'", "'subss'", "'t1mskc'", 
                     "'tdpbf16ps'", "'tdpbssd'", "'tdpbsud'", "'tdpbusd'", 
                     "'tdpbuud'", "'testui'", "'tileloadd'", "'tileloaddt1'", 
                     "'tilerelease'", "'tilestored'", "'tilezero'", "'tpause'", 
                     "'tzcnt'", "'tzmsk'", "'ucomisd'", "'ucomiss'", "'uiret'", 
                     "'umonitor'", "'umwait'", "'unpckhpd'", "'unpckhps'", 
                     "'unpcklpd'", "'unpcklps'", "'v4dpwssd'", "'v4dpwssds'", 
                     "'v4fmaddps'", "'v4fmaddss'", "'v4fnmaddps'", "'v4fnmaddss'", 
                     "'vaddpd'", "'vaddph'", "'vaddps'", "'vaddsd'", "'vaddsh'", 
                     "'vaddss'", "'vaddsubpd'", "'vaddsubps'", "'vaesdec'", 
                     "'vaesdeclast'", "'vaesenc'", "'vaesenclast'", "'vaesimc'", 
                     "'vaeskeygenassist'", "'valignd'", "'valignq'", "'vandnpd'", 
                     "'vandnps'", "'vandpd'", "'vandps'", "'vbcstnebf16ps'", 
                     "'vbcstnesh2ps'", "'vblendmpd'", "'vblendmps'", "'vblendpd'", 
                     "'vblendps'", "'vblendvpd'", "'vblendvps'", "'vbroadcastf128'", 
                     "'vbroadcastf32x2'", "'vbroadcastf32x4'", "'vbroadcastf32x8'", 
                     "'vbroadcastf64x2'", "'vbroadcastf64x4'", "'vbroadcasti128'", 
                     "'vbroadcasti32x2'", "'vbroadcasti32x4'", "'vbroadcasti32x8'", 
                     "'vbroadcasti64x2'", "'vbroadcasti64x4'", "'vbroadcastsd'", 
                     "'vbroadcastss'", "'vcmpeq_oqpd'", "'vcmpeq_oqps'", 
                     "'vcmpeq_oqsd'", "'vcmpeq_oqss'", "'vcmpeq_ospd'", 
                     "'vcmpeq_osps'", "'vcmpeq_ossd'", "'vcmpeq_osss'", 
                     "'vcmpeq_uqpd'", "'vcmpeq_uqps'", "'vcmpeq_uqsd'", 
                     "'vcmpeq_uqss'", "'vcmpeq_uspd'", "'vcmpeq_usps'", 
                     "'vcmpeq_ussd'", "'vcmpeq_usss'", "'vcmpeqpd'", "'vcmpeqps'", 
                     "'vcmpeqsd'", "'vcmpeqss'", "'vcmpfalse_oqpd'", "'vcmpfalse_oqps'", 
                     "'vcmpfalse_oqsd'", "'vcmpfalse_oqss'", "'vcmpfalse_ospd'", 
                     "'vcmpfalse_osps'", "'vcmpfalse_ossd'", "'vcmpfalse_osss'", 
                     "'vcmpfalsepd'", "'vcmpfalseps'", "'vcmpfalsesd'", 
                     "'vcmpfalsess'", "'vcmpge_oqpd'", "'vcmpge_oqps'", 
                     "'vcmpge_oqsd'", "'vcmpge_oqss'", "'vcmpge_ospd'", 
                     "'vcmpge_osps'", "'vcmpge_ossd'", "'vcmpge_osss'", 
                     "'vcmpgepd'", "'vcmpgeps'", "'vcmpgesd'", "'vcmpgess'", 
                     "'vcmpgt_oqpd'", "'vcmpgt_oqps'", "'vcmpgt_oqsd'", 
                     "'vcmpgt_oqss'", "'vcmpgt_ospd'", "'vcmpgt_osps'", 
                     "'vcmpgt_ossd'", "'vcmpgt_osss'", "'vcmpgtpd'", "'vcmpgtps'", 
                     "'vcmpgtsd'", "'vcmpgtss'", "'vcmple_oqpd'", "'vcmple_oqps'", 
                     "'vcmple_oqsd'", "'vcmple_oqss'", "'vcmple_ospd'", 
                     "'vcmple_osps'", "'vcmple_ossd'", "'vcmple_osss'", 
                     "'vcmplepd'", "'vcmpleps'", "'vcmplesd'", "'vcmpless'", 
                     "'vcmplt_oqpd'", "'vcmplt_oqps'", "'vcmplt_oqsd'", 
                     "'vcmplt_oqss'", "'vcmplt_ospd'", "'vcmplt_osps'", 
                     "'vcmplt_ossd'", "'vcmplt_osss'", "'vcmpltpd'", "'vcmpltps'", 
                     "'vcmpltsd'", "'vcmpltss'", "'vcmpneq_oqpd'", "'vcmpneq_oqps'", 
                     "'vcmpneq_oqsd'", "'vcmpneq_oqss'", "'vcmpneq_ospd'", 
                     "'vcmpneq_osps'", "'vcmpneq_ossd'", "'vcmpneq_osss'", 
                     "'vcmpneq_uqpd'", "'vcmpneq_uqps'", "'vcmpneq_uqsd'", 
                     "'vcmpneq_uqss'", "'vcmpneq_uspd'", "'vcmpneq_usps'", 
                     "'vcmpneq_ussd'", "'vcmpneq_usss'", "'vcmpneqpd'", 
                     "'vcmpneqps'", "'vcmpneqsd'", "'vcmpneqss'", "'vcmpnge_uqpd'", 
                     "'vcmpnge_uqps'", "'vcmpnge_uqsd'", "'vcmpnge_uqss'", 
                     "'vcmpnge_uspd'", "'vcmpnge_usps'", "'vcmpnge_ussd'", 
                     "'vcmpnge_usss'", "'vcmpngepd'", "'vcmpngeps'", "'vcmpngesd'", 
                     "'vcmpngess'", "'vcmpngt_uqpd'", "'vcmpngt_uqps'", 
                     "'vcmpngt_uqsd'", "'vcmpngt_uqss'", "'vcmpngt_uspd'", 
                     "'vcmpngt_usps'", "'vcmpngt_ussd'", "'vcmpngt_usss'", 
                     "'vcmpngtpd'", "'vcmpngtps'", "'vcmpngtsd'", "'vcmpngtss'", 
                     "'vcmpnle_uqpd'", "'vcmpnle_uqps'", "'vcmpnle_uqsd'", 
                     "'vcmpnle_uqss'", "'vcmpnle_uspd'", "'vcmpnle_usps'", 
                     "'vcmpnle_ussd'", "'vcmpnle_usss'", "'vcmpnlepd'", 
                     "'vcmpnleps'", "'vcmpnlesd'", "'vcmpnless'", "'vcmpnlt_uqpd'", 
                     "'vcmpnlt_uqps'", "'vcmpnlt_uqsd'", "'vcmpnlt_uqss'", 
                     "'vcmpnlt_uspd'", "'vcmpnlt_usps'", "'vcmpnlt_ussd'", 
                     "'vcmpnlt_usss'", "'vcmpnltpd'", "'vcmpnltps'", "'vcmpnltsd'", 
                     "'vcmpnltss'", "'vcmpord_qpd'", "'vcmpord_qps'", "'vcmpord_qsd'", 
                     "'vcmpord_qss'", "'vcmpord_spd'", "'vcmpord_sps'", 
                     "'vcmpord_ssd'", "'vcmpord_sss'", "'vcmpordpd'", "'vcmpordps'", 
                     "'vcmpordsd'", "'vcmpordss'", "'vcmppd'", "'vcmpph'", 
                     "'vcmpps'", "'vcmpsd'", "'vcmpsh'", "'vcmpss'", "'vcmptrue_uqpd'", 
                     "'vcmptrue_uqps'", "'vcmptrue_uqsd'", "'vcmptrue_uqss'", 
                     "'vcmptrue_uspd'", "'vcmptrue_usps'", "'vcmptrue_ussd'", 
                     "'vcmptrue_usss'", "'vcmptruepd'", "'vcmptrueps'", 
                     "'vcmptruesd'", "'vcmptruess'", "'vcmpunord_qpd'", 
                     "'vcmpunord_qps'", "'vcmpunord_qsd'", "'vcmpunord_qss'", 
                     "'vcmpunord_spd'", "'vcmpunord_sps'", "'vcmpunord_ssd'", 
                     "'vcmpunord_sss'", "'vcmpunordpd'", "'vcmpunordps'", 
                     "'vcmpunordsd'", "'vcmpunordss'", "'vcomisd'", "'vcomish'", 
                     "'vcomiss'", "'vcompresspd'", "'vcompressps'", "'vcvtdq2pd'", 
                     "'vcvtdq2ph'", "'vcvtdq2ps'", "'vcvtne2ps2bf16'", "'vcvtneebf162ps'", 
                     "'vcvtneeph2ps'", "'vcvtneobf162ps'", "'vcvtneoph2ps'", 
                     "'vcvtneps2bf16'", "'vcvtpd2dq'", "'vcvtpd2ph'", "'vcvtpd2ps'", 
                     "'vcvtpd2qq'", "'vcvtpd2udq'", "'vcvtpd2uqq'", "'vcvtph2dq'", 
                     "'vcvtph2pd'", "'vcvtph2ps'", "'vcvtph2psx'", "'vcvtph2qq'", 
                     "'vcvtph2udq'", "'vcvtph2uqq'", "'vcvtph2uw'", "'vcvtph2w'", 
                     "'vcvtps2dq'", "'vcvtps2pd'", "'vcvtps2ph'", "'vcvtps2qq'", 
                     "'vcvtps2udq'", "'vcvtps2uqq'", "'vcvtqq2pd'", "'vcvtqq2ph'", 
                     "'vcvtqq2ps'", "'vcvtsd2sh'", "'vcvtsd2si'", "'vcvtsd2ss'", 
                     "'vcvtsd2usi'", "'vcvtsh2sd'", "'vcvtsh2si'", "'vcvtsh2ss'", 
                     "'vcvtsh2usi'", "'vcvtsi2sd'", "'vcvtsi2sh'", "'vcvtsi2ss'", 
                     "'vcvtss2sd'", "'vcvtss2sh'", "'vcvtss2si'", "'vcvtss2usi'", 
                     "'vcvttpd2dq'", "'vcvttpd2qq'", "'vcvttpd2udq'", "'vcvttpd2uqq'", 
                     "'vcvttph2dq'", "'vcvttph2qq'", "'vcvttph2udq'", "'vcvttph2uqq'", 
                     "'vcvttph2uw'", "'vcvttph2w'", "'vcvttps2dq'", "'vcvttps2qq'", 
                     "'vcvttps2udq'", "'vcvttps2uqq'", "'vcvttsd2si'", "'vcvttsd2usi'", 
                     "'vcvttsh2si'", "'vcvttsh2usi'", "'vcvttss2si'", "'vcvttss2usi'", 
                     "'vcvtudq2pd'", "'vcvtudq2ph'", "'vcvtudq2ps'", "'vcvtuqq2pd'", 
                     "'vcvtuqq2ph'", "'vcvtuqq2ps'", "'vcvtusi2sd'", "'vcvtusi2sh'", 
                     "'vcvtusi2ss'", "'vcvtuw2ph'", "'vcvtw2ph'", "'vdbpsadbw'", 
                     "'vdivpd'", "'vdivph'", "'vdivps'", "'vdivsd'", "'vdivsh'", 
                     "'vdivss'", "'vdpbf16ps'", "'vdppd'", "'vdpps'", "'vendscaleph'", 
                     "'vendscalesh'", "'vexp2pd'", "'vexp2ps'", "'vexpandpd'", 
                     "'vexpandps'", "'vextractf128'", "'vextractf32x4'", 
                     "'vextractf32x8'", "'vextractf64x2'", "'vextractf64x4'", 
                     "'vextracti128'", "'vextracti32x4'", "'vextracti32x8'", 
                     "'vextracti64x2'", "'vextracti64x4'", "'vextractps'", 
                     "'vfcmaddcph'", "'vfcmaddcsh'", "'vfcmulcpch'", "'vfcmulcsh'", 
                     "'vfixupimmpd'", "'vfixupimmps'", "'vfixupimmsd'", 
                     "'vfixupimmss'", "'vfmadd123pd'", "'vfmadd123ps'", 
                     "'vfmadd123sd'", "'vfmadd123ss'", "'vfmadd132pd'", 
                     "'vfmadd132ph'", "'vfmadd132ps'", "'vfmadd132sd'", 
                     "'vfmadd132ss'", "'vfmadd213pd'", "'vfmadd213ph'", 
                     "'vfmadd213ps'", "'vfmadd213sd'", "'vfmadd213ss'", 
                     "'vfmadd231pd'", "'vfmadd231ph'", "'vfmadd231ps'", 
                     "'vfmadd231sd'", "'vfmadd231ss'", "'vfmadd312pd'", 
                     "'vfmadd312ps'", "'vfmadd312sd'", "'vfmadd312ss'", 
                     "'vfmadd321pd'", "'vfmadd321ps'", "'vfmadd321sd'", 
                     "'vfmadd321ss'", "'vfmaddcph'", "'vfmaddcsh'", "'vfmaddpd'", 
                     "'vfmaddps'", "'vfmaddsd'", "'vfmaddss'", "'vfmaddsub123pd'", 
                     "'vfmaddsub123ps'", "'vfmaddsub132pd'", "'vfmaddsub132ph'", 
                     "'vfmaddsub132ps'", "'vfmaddsub213pd'", "'vfmaddsub213ph'", 
                     "'vfmaddsub213ps'", "'vfmaddsub231pd'", "'vfmaddsub231ph'", 
                     "'vfmaddsub231ps'", "'vfmaddsub312pd'", "'vfmaddsub312ps'", 
                     "'vfmaddsub321pd'", "'vfmaddsub321ps'", "'vfmaddsubpd'", 
                     "'vfmaddsubps'", "'vfmsub123pd'", "'vfmsub123ps'", 
                     "'vfmsub123sd'", "'vfmsub123ss'", "'vfmsub132pd'", 
                     "'vfmsub132ph'", "'vfmsub132ps'", "'vfmsub132sd'", 
                     "'vfmsub132ss'", "'vfmsub213pd'", "'vfmsub213ph'", 
                     "'vfmsub213ps'", "'vfmsub213sd'", "'vfmsub213ss'", 
                     "'vfmsub231pd'", "'vfmsub231ph'", "'vfmsub231ps'", 
                     "'vfmsub231sd'", "'vfmsub231ss'", "'vfmsub312pd'", 
                     "'vfmsub312ps'", "'vfmsub312sd'", "'vfmsub312ss'", 
                     "'vfmsub321pd'", "'vfmsub321ps'", "'vfmsub321sd'", 
                     "'vfmsub321ss'", "'vfmsubadd123pd'", "'vfmsubadd123ps'", 
                     "'vfmsubadd132pd'", "'vfmsubadd132ph'", "'vfmsubadd132ps'", 
                     "'vfmsubadd213pd'", "'vfmsubadd213ph'", "'vfmsubadd213ps'", 
                     "'vfmsubadd231pd'", "'vfmsubadd231ph'", "'vfmsubadd231ps'", 
                     "'vfmsubadd312pd'", "'vfmsubadd312ps'", "'vfmsubadd321pd'", 
                     "'vfmsubadd321ps'", "'vfmsubaddpd'", "'vfmsubaddps'", 
                     "'vfmsubpd'", "'vfmsubps'", "'vfmsubsd'", "'vfmsubss'", 
                     "'vfmulcpch'", "'vfmulcsh'", "'vfnmadd123pd'", "'vfnmadd123ps'", 
                     "'vfnmadd123sd'", "'vfnmadd123ss'", "'vfnmadd132pd'", 
                     "'vfnmadd132ps'", "'vfnmadd132sd'", "'vfnmadd132ss'", 
                     "'vfnmadd213pd'", "'vfnmadd213ps'", "'vfnmadd213sd'", 
                     "'vfnmadd213ss'", "'vfnmadd231pd'", "'vfnmadd231ps'", 
                     "'vfnmadd231sd'", "'vfnmadd231ss'", "'vfnmadd312pd'", 
                     "'vfnmadd312ps'", "'vfnmadd312sd'", "'vfnmadd312ss'", 
                     "'vfnmadd321pd'", "'vfnmadd321ps'", "'vfnmadd321sd'", 
                     "'vfnmadd321ss'", "'vfnmaddpd'", "'vfnmaddps'", "'vfnmaddsd'", 
                     "'vfnmaddss'", "'vfnmsub123pd'", "'vfnmsub123ps'", 
                     "'vfnmsub123sd'", "'vfnmsub123ss'", "'vfnmsub132pd'", 
                     "'vfnmsub132ps'", "'vfnmsub132sd'", "'vfnmsub132ss'", 
                     "'vfnmsub213pd'", "'vfnmsub213ps'", "'vfnmsub213sd'", 
                     "'vfnmsub213ss'", "'vfnmsub231pd'", "'vfnmsub231ps'", 
                     "'vfnmsub231sd'", "'vfnmsub231ss'", "'vfnmsub312pd'", 
                     "'vfnmsub312ps'", "'vfnmsub312sd'", "'vfnmsub312ss'", 
                     "'vfnmsub321pd'", "'vfnmsub321ps'", "'vfnmsub321sd'", 
                     "'vfnmsub321ss'", "'vfnmsubpd'", "'vfnmsubps'", "'vfnmsubsd'", 
                     "'vfnmsubss'", "'vfpclasspd'", "'vfpclassph'", "'vfpclassps'", 
                     "'vfpclasssd'", "'vfpclasssh'", "'vfpclassss'", "'vfrczpd'", 
                     "'vfrczps'", "'vfrczsd'", "'vfrczss'", "'vgatherdpd'", 
                     "'vgatherdps'", "'vgatherpf0dpd'", "'vgatherpf0dps'", 
                     "'vgatherpf0qpd'", "'vgatherpf0qps'", "'vgatherpf1dpd'", 
                     "'vgatherpf1dps'", "'vgatherpf1qpd'", "'vgatherpf1qps'", 
                     "'vgatherqpd'", "'vgatherqps'", "'vgetexppd'", "'vgetexpph'", 
                     "'vgetexpps'", "'vgetexpsd'", "'vgetexpsh'", "'vgetexpss'", 
                     "'vgetmantpd'", "'vgetmantph'", "'vgetmantps'", "'vgetmantsd'", 
                     "'vgetmantsh'", "'vgetmantss'", "'vgetmaxph'", "'vgetmaxsh'", 
                     "'vgetminph'", "'vgetminsh'", "'vgf2p8affineinvqb'", 
                     "'vgf2p8affineqb'", "'vgf2p8mulb'", "'vhaddpd'", "'vhaddps'", 
                     "'vhsubpd'", "'vhsubps'", "'vinsertf128'", "'vinsertf32x4'", 
                     "'vinsertf32x8'", "'vinsertf64x2'", "'vinsertf64x4'", 
                     "'vinserti128'", "'vinserti32x4'", "'vinserti32x8'", 
                     "'vinserti64x2'", "'vinserti64x4'", "'vinsertps'", 
                     "'vlddqu'", "'vldmxcsr'", "'vldqqu'", "'vmaskmovdqu'", 
                     "'vmaskmovpd'", "'vmaskmovps'", "'vmaxpd'", "'vmaxps'", 
                     "'vmaxsd'", "'vmaxss'", "'vmcall'", "'vmclear'", "'vmfunc'", 
                     "'vmgexit'", "'vminpd'", "'vminps'", "'vminsd'", "'vminss'", 
                     "'vmlaunch'", "'vmload'", "'vmmcall'", "'vmovapd'", 
                     "'vmovaps'", "'vmovd'", "'vmovddup'", "'vmovdqa'", 
                     "'vmovdqa32'", "'vmovdqa64'", "'vmovdqu'", "'vmovdqu16'", 
                     "'vmovdqu32'", "'vmovdqu64'", "'vmovdqu8'", "'vmovhlps'", 
                     "'vmovhpd'", "'vmovhps'", "'vmovlhps'", "'vmovlpd'", 
                     "'vmovlps'", "'vmovmskpd'", "'vmovmskps'", "'vmovntdq'", 
                     "'vmovntdqa'", "'vmovntpd'", "'vmovntps'", "'vmovntqq'", 
                     "'vmovq'", "'vmovqqa'", "'vmovqqu'", "'vmovsd'", "'vmovsh'", 
                     "'vmovshdup'", "'vmovsldup'", "'vmovss'", "'vmovupd'", 
                     "'vmovups'", "'vmovw'", "'vmpsadbw'", "'vmptrld'", 
                     "'vmptrst'", "'vmread'", "'vmresume'", "'vmrun'", "'vmsave'", 
                     "'vmulpd'", "'vmulph'", "'vmulps'", "'vmulsd'", "'vmulsh'", 
                     "'vmulss'", "'vmwrite'", "'vmxoff'", "'vmxon'", "'vorpd'", 
                     "'vorps'", "'vp2intersectd'", "'vpabsb'", "'vpabsd'", 
                     "'vpabsq'", "'vpabsw'", "'vpackssdw'", "'vpacksswb'", 
                     "'vpackusdw'", "'vpackuswb'", "'vpaddb'", "'vpaddd'", 
                     "'vpaddq'", "'vpaddsb'", "'vpaddsw'", "'vpaddusb'", 
                     "'vpaddusw'", "'vpaddw'", "'vpalignr'", "'vpand'", 
                     "'vpandd'", "'vpandn'", "'vpandnd'", "'vpandnq'", "'vpandq'", 
                     "'vpavgb'", "'vpavgw'", "'vpblendd'", "'vpblendmb'", 
                     "'vpblendmd'", "'vpblendmq'", "'vpblendmw'", "'vpblendvb'", 
                     "'vpblendw'", "'vpbroadcastb'", "'vpbroadcastd'", "'vpbroadcastmb2q'", 
                     "'vpbroadcastmw2d'", "'vpbroadcastq'", "'vpbroadcastw'", 
                     "'vpclmulhqhqdq'", "'vpclmulhqlqdq'", "'vpclmullqhqdq'", 
                     "'vpclmullqlqdq'", "'vpclmulqdq'", "'vpcmov'", "'vpcmpb'", 
                     "'vpcmpd'", "'vpcmpeqb'", "'vpcmpeqd'", "'vpcmpeqq'", 
                     "'vpcmpequb'", "'vpcmpequd'", "'vpcmpequq'", "'vpcmpequw'", 
                     "'vpcmpeqw'", "'vpcmpestri'", "'vpcmpestrm'", "'vpcmpgeb'", 
                     "'vpcmpged'", "'vpcmpgeq'", "'vpcmpgeub'", "'vpcmpgeud'", 
                     "'vpcmpgeuq'", "'vpcmpgeuw'", "'vpcmpgew'", "'vpcmpgtb'", 
                     "'vpcmpgtd'", "'vpcmpgtq'", "'vpcmpgtub'", "'vpcmpgtud'", 
                     "'vpcmpgtuq'", "'vpcmpgtuw'", "'vpcmpgtw'", "'vpcmpistri'", 
                     "'vpcmpistrm'", "'vpcmpleb'", "'vpcmpled'", "'vpcmpleq'", 
                     "'vpcmpleub'", "'vpcmpleud'", "'vpcmpleuq'", "'vpcmpleuw'", 
                     "'vpcmplew'", "'vpcmpltb'", "'vpcmpltd'", "'vpcmpltq'", 
                     "'vpcmpltub'", "'vpcmpltud'", "'vpcmpltuq'", "'vpcmpltuw'", 
                     "'vpcmpltw'", "'vpcmpneqb'", "'vpcmpneqd'", "'vpcmpneqq'", 
                     "'vpcmpnequb'", "'vpcmpnequd'", "'vpcmpnequq'", "'vpcmpnequw'", 
                     "'vpcmpneqw'", "'vpcmpngtb'", "'vpcmpngtd'", "'vpcmpngtq'", 
                     "'vpcmpngtub'", "'vpcmpngtud'", "'vpcmpngtuq'", "'vpcmpngtuw'", 
                     "'vpcmpngtw'", "'vpcmpnleb'", "'vpcmpnled'", "'vpcmpnleq'", 
                     "'vpcmpnleub'", "'vpcmpnleud'", "'vpcmpnleuq'", "'vpcmpnleuw'", 
                     "'vpcmpnlew'", "'vpcmpnltb'", "'vpcmpnltd'", "'vpcmpnltq'", 
                     "'vpcmpnltub'", "'vpcmpnltud'", "'vpcmpnltuq'", "'vpcmpnltuw'", 
                     "'vpcmpnltw'", "'vpcmpq'", "'vpcmpub'", "'vpcmpud'", 
                     "'vpcmpuq'", "'vpcmpuw'", "'vpcmpw'", "'vpcomb'", "'vpcomd'", 
                     "'vpcompressb'", "'vpcompressd'", "'vpcompressq'", 
                     "'vpcompressw'", "'vpcomq'", "'vpcomub'", "'vpcomud'", 
                     "'vpcomuq'", "'vpcomuw'", "'vpcomw'", "'vpconflictd'", 
                     "'vpconflictq'", "'vpdpbssd'", "'vpdpbssds'", "'vpdpbsud'", 
                     "'vpdpbsuds'", "'vpdpbusd'", "'vpdpbusds'", "'vpdpbuud'", 
                     "'vpdpbuuds'", "'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'", "'vpextrb'", "'vpextrd'", "'vpextrq'", 
                     "'vpextrw'", "'vpgatherdd'", "'vpgatherdq'", "'vpgatherqd'", 
                     "'vpgatherqq'", "'vphaddbd'", "'vphaddbq'", "'vphaddbw'", 
                     "'vphaddd'", "'vphadddq'", "'vphaddsw'", "'vphaddubd'", 
                     "'vphaddubq'", "'vphaddubw'", "'vphaddudq'", "'vphadduwd'", 
                     "'vphadduwq'", "'vphaddw'", "'vphaddwd'", "'vphaddwq'", 
                     "'vphminposuw'", "'vphsubbw'", "'vphsubd'", "'vphsubdq'", 
                     "'vphsubsw'", "'vphsubw'", "'vphsubwd'", "'vpinsrb'", 
                     "'vpinsrd'", "'vpinsrq'", "'vpinsrw'", "'vplzcntd'", 
                     "'vplzcntq'", "'vpmacsdd'", "'vpmacsdqh'", "'vpmacsdql'", 
                     "'vpmacssdd'", "'vpmacssdqh'", "'vpmacssdql'", "'vpmacsswd'", 
                     "'vpmacssww'", "'vpmacswd'", "'vpmacsww'", "'vpmadcsswd'", 
                     "'vpmadcswd'", "'vpmadd132ph'", "'vpmadd132sh'", "'vpmadd213ph'", 
                     "'vpmadd213sh'", "'vpmadd231ph'", "'vpmadd231sh'", 
                     "'vpmadd52huq'", "'vpmadd52luq'", "'vpmaddubsw'", "'vpmaddwd'", 
                     "'vpmaskmovd'", "'vpmaskmovq'", "'vpmaxsb'", "'vpmaxsd'", 
                     "'vpmaxsq'", "'vpmaxsw'", "'vpmaxub'", "'vpmaxud'", 
                     "'vpmaxuq'", "'vpmaxuw'", "'vpminsb'", "'vpminsd'", 
                     "'vpminsq'", "'vpminsw'", "'vpminub'", "'vpminud'", 
                     "'vpminuq'", "'vpminuw'", "'vpmovb2m'", "'vpmovd2m'", 
                     "'vpmovdb'", "'vpmovdw'", "'vpmovm2b'", "'vpmovm2d'", 
                     "'vpmovm2q'", "'vpmovm2w'", "'vpmovmskb'", "'vpmovq2m'", 
                     "'vpmovqb'", "'vpmovqd'", "'vpmovqw'", "'vpmovsdb'", 
                     "'vpmovsdw'", "'vpmovsqb'", "'vpmovsqd'", "'vpmovsqw'", 
                     "'vpmovswb'", "'vpmovsxbd'", "'vpmovsxbq'", "'vpmovsxbw'", 
                     "'vpmovsxdq'", "'vpmovsxwd'", "'vpmovsxwq'", "'vpmovusdb'", 
                     "'vpmovusdw'", "'vpmovusqb'", "'vpmovusqd'", "'vpmovusqw'", 
                     "'vpmovuswb'", "'vpmovw2m'", "'vpmovwb'", "'vpmovzxbd'", 
                     "'vpmovzxbq'", "'vpmovzxbw'", "'vpmovzxdq'", "'vpmovzxwd'", 
                     "'vpmovzxwq'", "'vpmsub132ph'", "'vpmsub132sh'", "'vpmsub213ph'", 
                     "'vpmsub213sh'", "'vpmsub231ph'", "'vpmsub231sh'", 
                     "'vpmuldq'", "'vpmulhrsw'", "'vpmulhuw'", "'vpmulhw'", 
                     "'vpmulld'", "'vpmullq'", "'vpmullw'", "'vpmultishiftqb'", 
                     "'vpmuludq'", "'vpnmadd132sh'", "'vpnmadd213sh'", "'vpnmadd231sh'", 
                     "'vpnmsub132sh'", "'vpnmsub213sh'", "'vpnmsub231sh'", 
                     "'vpopcntb'", "'vpopcntd'", "'vpopcntq'", "'vpopcntw'", 
                     "'vpor'", "'vpord'", "'vporq'", "'vpperm'", "'vprold'", 
                     "'vprolq'", "'vprolvd'", "'vprolvq'", "'vprord'", "'vprorq'", 
                     "'vprorvd'", "'vprorvq'", "'vprotb'", "'vprotd'", "'vprotq'", 
                     "'vprotw'", "'vpsadbw'", "'vpscatterdd'", "'vpscatterdq'", 
                     "'vpscatterqd'", "'vpscatterqq'", "'vpshab'", "'vpshad'", 
                     "'vpshaq'", "'vpshaw'", "'vpshlb'", "'vpshld'", "'vpshldd'", 
                     "'vpshldq'", "'vpshldvd'", "'vpshldvq'", "'vpshldvw'", 
                     "'vpshldw'", "'vpshlq'", "'vpshlw'", "'vpshrdd'", "'vpshrdq'", 
                     "'vpshrdvd'", "'vpshrdvq'", "'vpshrdvw'", "'vpshrdw'", 
                     "'vpshufb'", "'vpshufbitqmb'", "'vpshufd'", "'vpshufhw'", 
                     "'vpshuflw'", "'vpsignb'", "'vpsignd'", "'vpsignw'", 
                     "'vpslld'", "'vpslldq'", "'vpsllq'", "'vpsllvd'", "'vpsllvq'", 
                     "'vpsllvw'", "'vpsllw'", "'vpsrad'", "'vpsraq'", "'vpsravd'", 
                     "'vpsravq'", "'vpsravw'", "'vpsraw'", "'vpsrld'", "'vpsrldq'", 
                     "'vpsrlq'", "'vpsrlvd'", "'vpsrlvq'", "'vpsrlvw'", 
                     "'vpsrlw'", "'vpsubb'", "'vpsubd'", "'vpsubq'", "'vpsubsb'", 
                     "'vpsubsw'", "'vpsubusb'", "'vpsubusw'", "'vpsubw'", 
                     "'vpternlogd'", "'vpternlogq'", "'vptest'", "'vptestmb'", 
                     "'vptestmd'", "'vptestmq'", "'vptestmw'", "'vptestnmb'", 
                     "'vptestnmd'", "'vptestnmq'", "'vptestnmw'", "'vpunpckhbw'", 
                     "'vpunpckhdq'", "'vpunpckhqdq'", "'vpunpckhwd'", "'vpunpcklbw'", 
                     "'vpunpckldq'", "'vpunpcklqdq'", "'vpunpcklwd'", "'vpxor'", 
                     "'vpxord'", "'vpxorq'", "'vrangepd'", "'vrangeps'", 
                     "'vrangesd'", "'vrangess'", "'vrcp14pd'", "'vrcp14ps'", 
                     "'vrcp14sd'", "'vrcp14ss'", "'vrcp28pd'", "'vrcp28ps'", 
                     "'vrcp28sd'", "'vrcp28ss'", "'vrcpph'", "'vrcpps'", 
                     "'vrcpsh'", "'vrcpss'", "'vreducepd'", "'vreduceph'", 
                     "'vreduceps'", "'vreducesd'", "'vreducesh'", "'vreducess'", 
                     "'vrndscalepd'", "'vrndscaleps'", "'vrndscalesd'", 
                     "'vrndscaless'", "'vroundpd'", "'vroundps'", "'vroundsd'", 
                     "'vroundss'", "'vrsqrt14pd'", "'vrsqrt14ps'", "'vrsqrt14sd'", 
                     "'vrsqrt14ss'", "'vrsqrt28pd'", "'vrsqrt28ps'", "'vrsqrt28sd'", 
                     "'vrsqrt28ss'", "'vrsqrtph'", "'vrsqrtps'", "'vrsqrtsh'", 
                     "'vrsqrtss'", "'vscalefpd'", "'vscalefph'", "'vscalefps'", 
                     "'vscalefsd'", "'vscalefsh'", "'vscalefss'", "'vscatterdpd'", 
                     "'vscatterdps'", "'vscatterpf0dpd'", "'vscatterpf0dps'", 
                     "'vscatterpf0qpd'", "'vscatterpf0qps'", "'vscatterpf1dpd'", 
                     "'vscatterpf1dps'", "'vscatterpf1qpd'", "'vscatterpf1qps'", 
                     "'vscatterqpd'", "'vscatterqps'", "'vshuff32x4'", "'vshuff64x2'", 
                     "'vshufi32x4'", "'vshufi64x2'", "'vshufpd'", "'vshufps'", 
                     "'vsqrtpd'", "'vsqrtph'", "'vsqrtps'", "'vsqrtsd'", 
                     "'vsqrtsh'", "'vsqrtss'", "'vstmxcsr'", "'vsubpd'", 
                     "'vsubph'", "'vsubps'", "'vsubsd'", "'vsubsh'", "'vsubss'", 
                     "'vtestpd'", "'vtestps'", "'vucomisd'", "'vucomish'", 
                     "'vucomiss'", "'vunpckhpd'", "'vunpckhps'", "'vunpcklpd'", 
                     "'vunpcklps'", "'vxorpd'", "'vxorps'", "'vzeroall'", 
                     "'vzeroupper'", "'wbnoinvd'", "'wrfsbase'", "'wrgsbase'", 
                     "'wrmsrlist'", "'wrmsrns'", "'wrpkru'", "'wrssd'", 
                     "'wrssq'", "'wrussd'", "'wrussq'", "'xabort'", "'xbegin'", 
                     "'xcryptcbc'", "'xcryptcfb'", "'xcryptctr'", "'xcryptecb'", 
                     "'xcryptofb'", "'xend'", "'xgetbv'", "'xorpd'", "'xorps'", 
                     "'xresldtrk'", "'xrstor'", "'xrstor64'", "'xrstors'", 
                     "'xrstors64'", "'xsave'", "'xsave64'", "'xsavec'", 
                     "'xsavec64'", "'xsaveopt'", "'xsaveopt64'", "'xsaves'", 
                     "'xsaves64'", "'xsetbv'", "'xsha1'", "'xsha256'", "'xstore'", 
                     "'xsusldtrk'", "'xtest'", "'bits'", "'use16'", "'use32'", 
                     "'default'", "'rel'", "'abs'", "'bnd'", "'nobnd'", 
                     "'sections'", "'section'", "'segments'", "'segment'", 
                     "'absolute'", "'extern'", "'required'", "'global'", 
                     "'common'", "'near'", "'far'", "'static'", "'cpu'", 
                     "'float'", "'daz'", "'nodaz'", "'up'", "'down'", "'zero'", 
                     "'warning'", "'org'", "'align'", "'vstart'", "'start'", 
                     "'progbits'", "'nobits'", "'vfollows'", "'follows'", 
                     "'map'", "'all'", "'brief'", "'symbols'", "'private'", 
                     "'public'", "'stack'", "'class'", "'overlay'", "'flat'", 
                     "'group'", "'uppercase'", "'import'", "'export'", "'resident'", 
                     "'nodata'", "'parm'", "'code'", "'text'", "'rdata'", 
                     "'data'", "'bss'", "'info'", "'comdat'", "'safeseh'", 
                     "'mixed'", "'zerofill'", "'no_dead_strip'", "'live_support'", 
                     "'strip_static_syms'", "'debug'", "'osabi'", "'note'", 
                     "'preinit_array'", "'init_array'", "'fini_array'", 
                     "'tls'", "'pointer'", "'noalloc'", "'alloc'", "'noexec'", 
                     "'exec'", "'nowrite'", "'write'", "'wrt'", "'function'", 
                     "'object'", "'weak'", "'strong'", "'internal'", "'hidden'", 
                     "'protected'", "'strict'", "'times'" ]

    symbolicNames = [ "<INVALID>", "DB", "DW", "DD", "DQ", "DT", "DO", "DY", 
                      "DZ", "RESB", "RESW", "RESD", "RESQ", "REST", "RESO", 
                      "RESY", "RESZ", "INCBIN", "BYTE", "WORD", "DWORD", 
                      "QWORD", "TWORD", "OWORD", "YWORD", "ZWORD", "DUP", 
                      "COMMA", "QUESTION", "LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", 
                      "LEFT_BRACKET", "RIGHT_BRACKET", "COLON", "BOOLEAN_OR", 
                      "BOOLEAN_XOR", "BOOLEAN_AND", "EQUAL_1", "EQUAL_2", 
                      "NOT_EQUAL_1", "NOT_EQUAL_2", "LESS_THAN", "LESS_THAN_EQUAL", 
                      "GREATER_THAN", "GREATER_THAN_EQUAL", "SIGNED_COMPARISON", 
                      "BITWISE_OR", "BITWISE_XOR", "BITWISE_AND", "LEFT_SHIFT", 
                      "RIGHT_SHIFT", "LEFT_SHIFT_COMPLETENESS", "RIGHT_SHIFT_COMPLETENESS", 
                      "PLUS", "MINUS", "MULTIPLICATION", "UNSIGNED_DIVISION", 
                      "SIGNED_DIVISION", "PERCENT", "SIGNED_MODULE", "BITWISE_NOT", 
                      "BOOLEAN_NOT", "DOLLAR", "DOUBLE_DOLLAR", "AAA", "AAD", 
                      "AAM", "AAS", "ADC", "ADD", "AND", "ARPL", "BB0_RESET", 
                      "BB1_RESET", "BOUND", "BSF", "BSR", "BSWAP", "BT", 
                      "BTC", "BTR", "BTS", "CALL", "CBW", "CDQ", "CDQE", 
                      "CLC", "CLD", "CLI", "CLTS", "CMC", "CMOVA", "CMOVAE", 
                      "CMOVB", "CMOVBE", "CMOVC", "CMOVE", "CMOVG", "CMOVGE", 
                      "CMOVL", "CMOVLE", "CMOVNA", "CMOVNAE", "CMOVNB", 
                      "CMOVNBE", "CMOVNC", "CMOVNE", "CMOVNG", "CMOVNGE", 
                      "CMOVNL", "CMOVNO", "CMOVNP", "CMOVNS", "CMOVNZ", 
                      "CMOVO", "CMOVP", "CMOVPE", "CMOVPO", "CMOVS", "CMOVZ", 
                      "CMP", "CMPSB", "CMPSD", "CMPSQ", "CMPSW", "CMPXCHG", 
                      "CMPXCHG16B", "CMPXCHG486", "CMPXCHG8B", "CPU_READ", 
                      "CPU_WRITE", "CPUID", "CQO", "CWD", "CWDE", "DAA", 
                      "DAS", "DEC", "DIV", "DMINT", "EMMS", "ENTER", "EQU", 
                      "F2XM1", "FABS", "FADD", "FADDP", "FBLD", "FBSTP", 
                      "FCHS", "FCLEX", "FCMOVB", "FCMOVBE", "FCMOVE", "FCMOVNB", 
                      "FCMOVNBE", "FCMOVNE", "FCMOVNU", "FCMOVU", "FCOM", 
                      "FCOMI", "FCOMIP", "FCOMP", "FCOMPP", "FCOS", "FDECSTP", 
                      "FDISI", "FDIV", "FDIVP", "FDIVR", "FDIVRP", "FEMMS", 
                      "FENI", "FFREE", "FFREEP", "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", 
                      "FNDISI", "FNENI", "FNINIT", "FNOP", "FNSAVE", "FNSTCW", 
                      "FNSTENV", "FNSTSW", "FPATAN", "FPREM", "FPREM1", 
                      "FPTAN", "FRNDINT", "FRSTOR", "FSAVE", "FSCALE", "FSETPM", 
                      "FSIN", "FSINCOS", "FSQRT", "FST", "FSTCW", "FSTENV", 
                      "FSTP", "FSTSW", "FSUB", "FSUBP", "FSUBR", "FSUBRP", 
                      "FTST", "FUCOM", "FUCOMI", "FUCOMIP", "FUCOMP", "FUCOMPP", 
                      "FWAIT", "FXAM", "FXCH", "FXTRACT", "FYL2X", "FYL2XP1", 
                      "HLT", "IBTS", "ICEBP", "IDIV", "IMUL", "IN", "INC", 
                      "INSB", "INSD", "INSW", "INT", "INT01", "INT03", "INT1", 
                      "INT3", "INTO", "INVD", "INVLPG", "INVLPGA", "INVPCID", 
                      "IRET", "IRETD", "IRETQ", "IRETW", "JA", "JAE", "JB", 
                      "JBE", "JC", "JCXZ", "JE", "JECXZ", "JG", "JGE", "JL", 
                      "JLE", "JMP", "JMPE", "JNA", "JNAE", "JNB", "JNBE", 
                      "JNC", "JNE", "JNG", "JNGE", "JNL", "JNLE", "JNO", 
                      "JNP", "JNS", "JNZ", "JO", "JP", "JPE", "JPO", "JRCXZ", 
                      "JS", "JZ", "LAHF", "LAR", "LDS", "LEA", "LEAVE", 
                      "LES", "LFENCE", "LFS", "LGDT", "LGS", "LIDT", "LLDT", 
                      "LMSW", "LOADALL", "LOADALL286", "LODSB", "LODSD", 
                      "LODSQ", "LODSW", "LOOP", "LOOPE", "LOOPNE", "LOOPNZ", 
                      "LOOPZ", "LSL", "LSS", "LTR", "MFENCE", "MONITOR", 
                      "MONITORX", "MOV", "MOVD", "MOVQ", "MOVSB", "MOVSD", 
                      "MOVSQ", "MOVSW", "MOVSX", "MOVSXD", "MOVZX", "MUL", 
                      "MWAIT", "MWAITX", "NEG", "NOP", "NOT", "OR", "OUT", 
                      "OUTSB", "OUTSD", "OUTSW", "PACKSSDW", "PACKSSWB", 
                      "PACKUSWB", "PADDB", "PADDD", "PADDSB", "PADDSIW", 
                      "PADDSW", "PADDUSB", "PADDUSW", "PADDW", "PAND", "PANDN", 
                      "PAUSE", "PAVEB", "PAVGUSB", "PCMPEQB", "PCMPEQD", 
                      "PCMPEQW", "PCMPGTB", "PCMPGTD", "PCMPGTW", "PDISTIB", 
                      "PF2ID", "PFACC", "PFADD", "PFCMPEQ", "PFCMPGE", "PFCMPGT", 
                      "PFMAX", "PFMIN", "PFMUL", "PFRCP", "PFRCPIT1", "PFRCPIT2", 
                      "PFRSQIT1", "PFRSQRT", "PFSUB", "PFSUBR", "PI2FD", 
                      "PMACHRIW", "PMADDWD", "PMAGW", "PMULHRIW", "PMULHRWA", 
                      "PMULHRWC", "PMULHW", "PMULLW", "PMVGEZB", "PMVLZB", 
                      "PMVNZB", "PMVZB", "POP", "POPA", "POPAD", "POPAW", 
                      "POPF", "POPFD", "POPFQ", "POPFW", "POR", "PREFETCH", 
                      "PREFETCHW", "PSLLD", "PSLLQ", "PSLLW", "PSRAD", "PSRAW", 
                      "PSRLD", "PSRLQ", "PSRLW", "PSUBB", "PSUBD", "PSUBSB", 
                      "PSUBSIW", "PSUBSW", "PSUBUSB", "PSUBUSW", "PSUBW", 
                      "PUNPCKHBW", "PUNPCKHDQ", "PUNPCKHWD", "PUNPCKLBW", 
                      "PUNPCKLDQ", "PUNPCKLWD", "PUSH", "PUSHA", "PUSHAD", 
                      "PUSHAW", "PUSHF", "PUSHFD", "PUSHFQ", "PUSHFW", "PXOR", 
                      "RCL", "RCR", "RDM", "RDMSR", "RDPMC", "RDSHR", "RDTSC", 
                      "RDTSCP", "RET", "RETD", "RETF", "RETFD", "RETFQ", 
                      "RETFW", "RETN", "RETND", "RETNQ", "RETNW", "RETQ", 
                      "RETW", "ROL", "ROR", "RSDC", "RSLDT", "RSM", "RSTS", 
                      "SAHF", "SAL", "SALC", "SAR", "SBB", "SCASB", "SCASD", 
                      "SCASQ", "SCASW", "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", "SHL", "SHLD", "SHR", 
                      "SHRD", "SIDT", "SKINIT", "SLDT", "SMI", "SMINT", 
                      "SMINTOLD", "SMSW", "STC", "STD", "STI", "STOSB", 
                      "STOSD", "STOSQ", "STOSW", "STR", "SUB", "SVDC", "SVLDT", 
                      "SVTS", "SWAPGS", "SYSCALL", "SYSENTER", "SYSEXIT", 
                      "SYSRET", "TEST", "UD0", "UD1", "UD2", "UD2A", "UD2B", 
                      "UMOV", "VERR", "VERW", "WBINVD", "WRMSR", "WRSHR", 
                      "XADD", "XBTS", "XCHG", "XLAT", "XLATB", "XOR", "AL", 
                      "AH", "AX", "EAX", "RAX", "BL", "BH", "BX", "EBX", 
                      "RBX", "CL", "CH", "CX", "ECX", "RCX", "DL", "DH", 
                      "DX", "EDX", "RDX", "SPL", "SP", "ESP", "RSP", "BPL", 
                      "BP", "EBP", "RBP", "SIL", "SI", "ESI", "RSI", "DIL", 
                      "DI", "EDI", "RDI", "R8B", "R9B", "R10B", "R11B", 
                      "R12B", "R13B", "R14B", "R15B", "R8W", "R9W", "R10W", 
                      "R11W", "R12W", "R13W", "R14W", "R15W", "R8D", "R9D", 
                      "R10D", "R11D", "R12D", "R13D", "R14D", "R15D", "R8", 
                      "R9", "R10", "R11", "R12", "R13", "R14", "R15", "IP", 
                      "EIP", "RIP", "ES", "CS", "SS", "DS", "FS", "GS", 
                      "SEGR6", "SEGR7", "CR0", "CR1", "CR2", "CR3", "CR4", 
                      "CR5", "CR6", "CR7", "CR8", "CR9", "CR10", "CR11", 
                      "CR12", "CR13", "CR14", "CR15", "DR0", "DR1", "DR2", 
                      "DR3", "DR4", "DR5", "DR6", "DR7", "DR8", "DR9", "DR10", 
                      "DR11", "DR12", "DR13", "DR14", "DR15", "TR0", "TR1", 
                      "TR2", "TR3", "TR4", "TR5", "TR6", "TR7", "ST0", "ST1", 
                      "ST2", "ST3", "ST4", "ST5", "ST6", "ST7", "MM0", "MM1", 
                      "MM2", "MM3", "MM4", "MM5", "MM6", "MM7", "XMM0", 
                      "XMM1", "XMM2", "XMM3", "XMM4", "XMM5", "XMM6", "XMM7", 
                      "XMM8", "XMM9", "XMM10", "XMM11", "XMM12", "XMM13", 
                      "XMM14", "XMM15", "XMM16", "XMM17", "XMM18", "XMM19", 
                      "XMM20", "XMM21", "XMM22", "XMM23", "XMM24", "XMM25", 
                      "XMM26", "XMM27", "XMM28", "XMM29", "XMM30", "XMM31", 
                      "YMM0", "YMM1", "YMM2", "YMM3", "YMM4", "YMM5", "YMM6", 
                      "YMM7", "YMM8", "YMM9", "YMM10", "YMM11", "YMM12", 
                      "YMM13", "YMM14", "YMM15", "YMM16", "YMM17", "YMM18", 
                      "YMM19", "YMM20", "YMM21", "YMM22", "YMM23", "YMM24", 
                      "YMM25", "YMM26", "YMM27", "YMM28", "YMM29", "YMM30", 
                      "YMM31", "ZMM0", "ZMM1", "ZMM2", "ZMM3", "ZMM4", "ZMM5", 
                      "ZMM6", "ZMM7", "ZMM8", "ZMM9", "ZMM10", "ZMM11", 
                      "ZMM12", "ZMM13", "ZMM14", "ZMM15", "ZMM16", "ZMM17", 
                      "ZMM18", "ZMM19", "ZMM20", "ZMM21", "ZMM22", "ZMM23", 
                      "ZMM24", "ZMM25", "ZMM26", "ZMM27", "ZMM28", "ZMM29", 
                      "ZMM30", "ZMM31", "TMM0", "TMM1", "TMM2", "TMM3", 
                      "TMM4", "TMM5", "TMM6", "TMM7", "K0", "K1", "K2", 
                      "K3", "K4", "K5", "K6", "K7", "BND0", "BND1", "BND2", 
                      "BND3", "AADD", "AAND", "ADCX", "ADDPD", "ADDPS", 
                      "ADDSD", "ADDSS", "ADDSUBPD", "ADDSUBPS", "ADOX", 
                      "AESDEC", "AESDECLAST", "AESENC", "AESENCLAST", "AESIMC", 
                      "AESKEYGENASSIST", "ANDN", "ANDNPD", "ANDNPS", "ANDPD", 
                      "ANDPS", "AXOR", "BEXTR", "BLCFILL", "BLCI", "BLCIC", 
                      "BLCMSK", "BLCS", "BLENDPD", "BLENDPS", "BLENDVPD", 
                      "BLENDVPS", "BLSFILL", "BLSI", "BLSIC", "BLSMSK", 
                      "BLSR", "BNDCL", "BNDCN", "BNDCU", "BNDLDX", "BNDMK", 
                      "BNDMOV", "BNDSTX", "BZHI", "CLAC", "CLDEMOTE", "CLFLUSH", 
                      "CLFLUSHOPT", "CLGI", "CLRSSBSY", "CLUI", "CLWB", 
                      "CLZERO", "CMPEQPD", "CMPEQPS", "CMPEQSD", "CMPEQSS", 
                      "CMPLEPD", "CMPLEPS", "CMPLESD", "CMPLESS", "CMPLTPD", 
                      "CMPLTPS", "CMPLTSD", "CMPLTSS", "CMPNEQPD", "CMPNEQPS", 
                      "CMPNEQSD", "CMPNEQSS", "CMPNLEPD", "CMPNLEPS", "CMPNLESD", 
                      "CMPNLESS", "CMPNLTPD", "CMPNLTPS", "CMPNLTSD", "CMPNLTSS", 
                      "CMPNPXADD", "CMPNSXADD", "CMPNZXADD", "CMPORDPD", 
                      "CMPORDPS", "CMPORDSD", "CMPORDSS", "CMPOXADD", "CMPPD", 
                      "CMPPS", "CMPPXADD", "CMPSS", "CMPSXADD", "CMPUNORDPD", 
                      "CMPUNORDPS", "CMPUNORDSD", "CMPUNORDSS", "CMPZXADD", 
                      "COMISD", "COMISS", "CRC32", "CVTDQ2PD", "CVTDQ2PS", 
                      "CVTPD2DQ", "CVTPD2PI", "CVTPD2PS", "CVTPI2PD", "CVTPI2PS", 
                      "CVTPS2DQ", "CVTPS2PD", "CVTPS2PI", "CVTSD2SI", "CVTSD2SS", 
                      "CVTSI2SD", "CVTSI2SS", "CVTSS2SD", "CVTSS2SI", "CVTTPD2DQ", 
                      "CVTTPD2PI", "CVTTPS2DQ", "CVTTPS2PI", "CVTTSD2SI", 
                      "CVTTSS2SI", "DIVPD", "DIVPS", "DIVSD", "DIVSS", "DPPD", 
                      "DPPS", "ENCLS", "ENCLU", "ENCLV", "ENDBR32", "ENDBR64", 
                      "ENQCMD", "ENQCMDS", "EXTRACTPS", "EXTRQ", "FXRSTOR", 
                      "FXRSTOR64", "FXSAVE", "FXSAVE64", "GETSEC", "GF2P8AFFINEINVQB", 
                      "GF2P8AFFINEQB", "GF2P8MULB", "HADDPD", "HADDPS", 
                      "HINT_NOP0", "HINT_NOP1", "HINT_NOP10", "HINT_NOP11", 
                      "HINT_NOP12", "HINT_NOP13", "HINT_NOP14", "HINT_NOP15", 
                      "HINT_NOP16", "HINT_NOP17", "HINT_NOP18", "HINT_NOP19", 
                      "HINT_NOP2", "HINT_NOP20", "HINT_NOP21", "HINT_NOP22", 
                      "HINT_NOP23", "HINT_NOP24", "HINT_NOP25", "HINT_NOP26", 
                      "HINT_NOP27", "HINT_NOP28", "HINT_NOP29", "HINT_NOP3", 
                      "HINT_NOP30", "HINT_NOP31", "HINT_NOP32", "HINT_NOP33", 
                      "HINT_NOP34", "HINT_NOP35", "HINT_NOP36", "HINT_NOP37", 
                      "HINT_NOP38", "HINT_NOP39", "HINT_NOP4", "HINT_NOP40", 
                      "HINT_NOP41", "HINT_NOP42", "HINT_NOP43", "HINT_NOP44", 
                      "HINT_NOP45", "HINT_NOP46", "HINT_NOP47", "HINT_NOP48", 
                      "HINT_NOP49", "HINT_NOP5", "HINT_NOP50", "HINT_NOP51", 
                      "HINT_NOP52", "HINT_NOP53", "HINT_NOP54", "HINT_NOP55", 
                      "HINT_NOP56", "HINT_NOP57", "HINT_NOP58", "HINT_NOP59", 
                      "HINT_NOP6", "HINT_NOP60", "HINT_NOP61", "HINT_NOP62", 
                      "HINT_NOP63", "HINT_NOP7", "HINT_NOP8", "HINT_NOP9", 
                      "HRESET", "HSUBPD", "HSUBPS", "INCSSPD", "INCSSPQ", 
                      "INSERTPS", "INSERTQ", "INVEPT", "INVVPID", "KADD", 
                      "KADDB", "KADDD", "KADDQ", "KADDW", "KAND", "KANDB", 
                      "KANDD", "KANDN", "KANDNB", "KANDND", "KANDNQ", "KANDNW", 
                      "KANDQ", "KANDW", "KMOV", "KMOVB", "KMOVD", "KMOVQ", 
                      "KMOVW", "KNOT", "KNOTB", "KNOTD", "KNOTQ", "KNOTW", 
                      "KOR", "KORB", "KORD", "KORQ", "KORTEST", "KORTESTB", 
                      "KORTESTD", "KORTESTQ", "KORTESTW", "KORW", "KSHIFTL", 
                      "KSHIFTLB", "KSHIFTLD", "KSHIFTLQ", "KSHIFTLW", "KSHIFTR", 
                      "KSHIFTRB", "KSHIFTRD", "KSHIFTRQ", "KSHIFTRW", "KTEST", 
                      "KTESTB", "KTESTD", "KTESTQ", "KTESTW", "KUNPCK", 
                      "KUNPCKBW", "KUNPCKDQ", "KUNPCKWD", "KXNOR", "KXNORB", 
                      "KXNORD", "KXNORQ", "KXNORW", "KXOR", "KXORB", "KXORD", 
                      "KXORQ", "KXORW", "LDDQU", "LDMXCSR", "LDTILECFG", 
                      "LLWPCB", "LWPINS", "LWPVAL", "LZCNT", "MASKMOVDQU", 
                      "MASKMOVQ", "MAXPD", "MAXPS", "MAXSD", "MAXSS", "MINPD", 
                      "MINPS", "MINSD", "MINSS", "MONTMUL", "MOVAPD", "MOVAPS", 
                      "MOVBE", "MOVDDUP", "MOVDIR64B", "MOVDIRI", "MOVDQ2Q", 
                      "MOVDQA", "MOVDQU", "MOVHLPS", "MOVHPD", "MOVHPS", 
                      "MOVLHPS", "MOVLPD", "MOVLPS", "MOVMSKPD", "MOVMSKPS", 
                      "MOVNTDQ", "MOVNTDQA", "MOVNTI", "MOVNTPD", "MOVNTPS", 
                      "MOVNTQ", "MOVNTSD", "MOVNTSS", "MOVQ2DQ", "MOVSHDUP", 
                      "MOVSLDUP", "MOVSS", "MOVUPD", "MOVUPS", "MPSADBW", 
                      "MULPD", "MULPS", "MULSD", "MULSS", "MULX", "ORPD", 
                      "ORPS", "PABSB", "PABSD", "PABSW", "PACKUSDW", "PADDQ", 
                      "PALIGNR", "PAVGB", "PAVGW", "PBLENDVB", "PBLENDW", 
                      "PCLMULHQHQDQ", "PCLMULHQLQDQ", "PCLMULLQHQDQ", "PCLMULLQLQDQ", 
                      "PCLMULQDQ", "PCMPEQQ", "PCMPESTRI", "PCMPESTRM", 
                      "PCMPGTQ", "PCMPISTRI", "PCMPISTRM", "PCOMMIT", "PCONFIG", 
                      "PDEP", "PEXT", "PEXTRB", "PEXTRD", "PEXTRQ", "PEXTRW", 
                      "PF2IW", "PFNACC", "PFPNACC", "PFRCPV", "PFRSQRTV", 
                      "PHADDD", "PHADDSW", "PHADDW", "PHMINPOSUW", "PHSUBD", 
                      "PHSUBSW", "PHSUBW", "PI2FW", "PINSRB", "PINSRD", 
                      "PINSRQ", "PINSRW", "PMADDUBSW", "PMAXSB", "PMAXSD", 
                      "PMAXSW", "PMAXUB", "PMAXUD", "PMAXUW", "PMINSB", 
                      "PMINSD", "PMINSW", "PMINUB", "PMINUD", "PMINUW", 
                      "PMOVMSKB", "PMOVSXBD", "PMOVSXBQ", "PMOVSXBW", "PMOVSXDQ", 
                      "PMOVSXWD", "PMOVSXWQ", "PMOVZXBD", "PMOVZXBQ", "PMOVZXBW", 
                      "PMOVZXDQ", "PMOVZXWD", "PMOVZXWQ", "PMULDQ", "PMULHRSW", 
                      "PMULHUW", "PMULLD", "PMULUDQ", "POPCNT", "PREFETCHIT0", 
                      "PREFETCHIT1", "PREFETCHNTA", "PREFETCHT0", "PREFETCHT1", 
                      "PREFETCHT2", "PREFETCHWT1", "PSADBW", "PSHUFB", "PSHUFD", 
                      "PSHUFHW", "PSHUFLW", "PSHUFW", "PSIGNB", "PSIGND", 
                      "PSIGNW", "PSLLDQ", "PSRLDQ", "PSUBQ", "PSWAPD", "PTEST", 
                      "PTWRITE", "PUNPCKHQDQ", "PUNPCKLQDQ", "PVALIDATE", 
                      "RCPPS", "RCPSS", "RDFSBASE", "RDGSBASE", "RDMSRLIST", 
                      "RDPID", "RDPKRU", "RDRAND", "RDSEED", "RDSSPD", "RDSSPQ", 
                      "RMPADJUST", "RORX", "ROUNDPD", "ROUNDPS", "ROUNDSD", 
                      "ROUNDSS", "RSQRTPS", "RSQRTSS", "RSTORSSP", "SARX", 
                      "SAVEPREVSSP", "SENDUIPI", "SERIALIZE", "SETSSBSY", 
                      "SHA1MSG1", "SHA1MSG2", "SHA1NEXTE", "SHA1RNDS4", 
                      "SHA256MSG1", "SHA256MSG2", "SHA256RNDS2", "SHLX", 
                      "SHRX", "SHUFPD", "SHUFPS", "SLWPCB", "SQRTPD", "SQRTPS", 
                      "SQRTSD", "SQRTSS", "STAC", "STGI", "STMXCSR", "STTILECFG", 
                      "STUI", "SUBPD", "SUBPS", "SUBSD", "SUBSS", "T1MSKC", 
                      "TDPBF16PS", "TDPBSSD", "TDPBSUD", "TDPBUSD", "TDPBUUD", 
                      "TESTUI", "TILELOADD", "TILELOADDT1", "TILERELEASE", 
                      "TILESTORED", "TILEZERO", "TPAUSE", "TZCNT", "TZMSK", 
                      "UCOMISD", "UCOMISS", "UIRET", "UMONITOR", "UMWAIT", 
                      "UNPCKHPD", "UNPCKHPS", "UNPCKLPD", "UNPCKLPS", "V4DPWSSD", 
                      "V4DPWSSDS", "V4FMADDPS", "V4FMADDSS", "V4FNMADDPS", 
                      "V4FNMADDSS", "VADDPD", "VADDPH", "VADDPS", "VADDSD", 
                      "VADDSH", "VADDSS", "VADDSUBPD", "VADDSUBPS", "VAESDEC", 
                      "VAESDECLAST", "VAESENC", "VAESENCLAST", "VAESIMC", 
                      "VAESKEYGENASSIST", "VALIGND", "VALIGNQ", "VANDNPD", 
                      "VANDNPS", "VANDPD", "VANDPS", "VBCSTNEBF16PS", "VBCSTNESH2PS", 
                      "VBLENDMPD", "VBLENDMPS", "VBLENDPD", "VBLENDPS", 
                      "VBLENDVPD", "VBLENDVPS", "VBROADCASTF128", "VBROADCASTF32X2", 
                      "VBROADCASTF32X4", "VBROADCASTF32X8", "VBROADCASTF64X2", 
                      "VBROADCASTF64X4", "VBROADCASTI128", "VBROADCASTI32X2", 
                      "VBROADCASTI32X4", "VBROADCASTI32X8", "VBROADCASTI64X2", 
                      "VBROADCASTI64X4", "VBROADCASTSD", "VBROADCASTSS", 
                      "VCMPEQ_OQPD", "VCMPEQ_OQPS", "VCMPEQ_OQSD", "VCMPEQ_OQSS", 
                      "VCMPEQ_OSPD", "VCMPEQ_OSPS", "VCMPEQ_OSSD", "VCMPEQ_OSSS", 
                      "VCMPEQ_UQPD", "VCMPEQ_UQPS", "VCMPEQ_UQSD", "VCMPEQ_UQSS", 
                      "VCMPEQ_USPD", "VCMPEQ_USPS", "VCMPEQ_USSD", "VCMPEQ_USSS", 
                      "VCMPEQPD", "VCMPEQPS", "VCMPEQSD", "VCMPEQSS", "VCMPFALSE_OQPD", 
                      "VCMPFALSE_OQPS", "VCMPFALSE_OQSD", "VCMPFALSE_OQSS", 
                      "VCMPFALSE_OSPD", "VCMPFALSE_OSPS", "VCMPFALSE_OSSD", 
                      "VCMPFALSE_OSSS", "VCMPFALSEPD", "VCMPFALSEPS", "VCMPFALSESD", 
                      "VCMPFALSESS", "VCMPGE_OQPD", "VCMPGE_OQPS", "VCMPGE_OQSD", 
                      "VCMPGE_OQSS", "VCMPGE_OSPD", "VCMPGE_OSPS", "VCMPGE_OSSD", 
                      "VCMPGE_OSSS", "VCMPGEPD", "VCMPGEPS", "VCMPGESD", 
                      "VCMPGESS", "VCMPGT_OQPD", "VCMPGT_OQPS", "VCMPGT_OQSD", 
                      "VCMPGT_OQSS", "VCMPGT_OSPD", "VCMPGT_OSPS", "VCMPGT_OSSD", 
                      "VCMPGT_OSSS", "VCMPGTPD", "VCMPGTPS", "VCMPGTSD", 
                      "VCMPGTSS", "VCMPLE_OQPD", "VCMPLE_OQPS", "VCMPLE_OQSD", 
                      "VCMPLE_OQSS", "VCMPLE_OSPD", "VCMPLE_OSPS", "VCMPLE_OSSD", 
                      "VCMPLE_OSSS", "VCMPLEPD", "VCMPLEPS", "VCMPLESD", 
                      "VCMPLESS", "VCMPLT_OQPD", "VCMPLT_OQPS", "VCMPLT_OQSD", 
                      "VCMPLT_OQSS", "VCMPLT_OSPD", "VCMPLT_OSPS", "VCMPLT_OSSD", 
                      "VCMPLT_OSSS", "VCMPLTPD", "VCMPLTPS", "VCMPLTSD", 
                      "VCMPLTSS", "VCMPNEQ_OQPD", "VCMPNEQ_OQPS", "VCMPNEQ_OQSD", 
                      "VCMPNEQ_OQSS", "VCMPNEQ_OSPD", "VCMPNEQ_OSPS", "VCMPNEQ_OSSD", 
                      "VCMPNEQ_OSSS", "VCMPNEQ_UQPD", "VCMPNEQ_UQPS", "VCMPNEQ_UQSD", 
                      "VCMPNEQ_UQSS", "VCMPNEQ_USPD", "VCMPNEQ_USPS", "VCMPNEQ_USSD", 
                      "VCMPNEQ_USSS", "VCMPNEQPD", "VCMPNEQPS", "VCMPNEQSD", 
                      "VCMPNEQSS", "VCMPNGE_UQPD", "VCMPNGE_UQPS", "VCMPNGE_UQSD", 
                      "VCMPNGE_UQSS", "VCMPNGE_USPD", "VCMPNGE_USPS", "VCMPNGE_USSD", 
                      "VCMPNGE_USSS", "VCMPNGEPD", "VCMPNGEPS", "VCMPNGESD", 
                      "VCMPNGESS", "VCMPNGT_UQPD", "VCMPNGT_UQPS", "VCMPNGT_UQSD", 
                      "VCMPNGT_UQSS", "VCMPNGT_USPD", "VCMPNGT_USPS", "VCMPNGT_USSD", 
                      "VCMPNGT_USSS", "VCMPNGTPD", "VCMPNGTPS", "VCMPNGTSD", 
                      "VCMPNGTSS", "VCMPNLE_UQPD", "VCMPNLE_UQPS", "VCMPNLE_UQSD", 
                      "VCMPNLE_UQSS", "VCMPNLE_USPD", "VCMPNLE_USPS", "VCMPNLE_USSD", 
                      "VCMPNLE_USSS", "VCMPNLEPD", "VCMPNLEPS", "VCMPNLESD", 
                      "VCMPNLESS", "VCMPNLT_UQPD", "VCMPNLT_UQPS", "VCMPNLT_UQSD", 
                      "VCMPNLT_UQSS", "VCMPNLT_USPD", "VCMPNLT_USPS", "VCMPNLT_USSD", 
                      "VCMPNLT_USSS", "VCMPNLTPD", "VCMPNLTPS", "VCMPNLTSD", 
                      "VCMPNLTSS", "VCMPORD_QPD", "VCMPORD_QPS", "VCMPORD_QSD", 
                      "VCMPORD_QSS", "VCMPORD_SPD", "VCMPORD_SPS", "VCMPORD_SSD", 
                      "VCMPORD_SSS", "VCMPORDPD", "VCMPORDPS", "VCMPORDSD", 
                      "VCMPORDSS", "VCMPPD", "VCMPPH", "VCMPPS", "VCMPSD", 
                      "VCMPSH", "VCMPSS", "VCMPTRUE_UQPD", "VCMPTRUE_UQPS", 
                      "VCMPTRUE_UQSD", "VCMPTRUE_UQSS", "VCMPTRUE_USPD", 
                      "VCMPTRUE_USPS", "VCMPTRUE_USSD", "VCMPTRUE_USSS", 
                      "VCMPTRUEPD", "VCMPTRUEPS", "VCMPTRUESD", "VCMPTRUESS", 
                      "VCMPUNORD_QPD", "VCMPUNORD_QPS", "VCMPUNORD_QSD", 
                      "VCMPUNORD_QSS", "VCMPUNORD_SPD", "VCMPUNORD_SPS", 
                      "VCMPUNORD_SSD", "VCMPUNORD_SSS", "VCMPUNORDPD", "VCMPUNORDPS", 
                      "VCMPUNORDSD", "VCMPUNORDSS", "VCOMISD", "VCOMISH", 
                      "VCOMISS", "VCOMPRESSPD", "VCOMPRESSPS", "VCVTDQ2PD", 
                      "VCVTDQ2PH", "VCVTDQ2PS", "VCVTNE2PS2BF16", "VCVTNEEBF162PS", 
                      "VCVTNEEPH2PS", "VCVTNEOBF162PS", "VCVTNEOPH2PS", 
                      "VCVTNEPS2BF16", "VCVTPD2DQ", "VCVTPD2PH", "VCVTPD2PS", 
                      "VCVTPD2QQ", "VCVTPD2UDQ", "VCVTPD2UQQ", "VCVTPH2DQ", 
                      "VCVTPH2PD", "VCVTPH2PS", "VCVTPH2PSX", "VCVTPH2QQ", 
                      "VCVTPH2UDQ", "VCVTPH2UQQ", "VCVTPH2UW", "VCVTPH2W", 
                      "VCVTPS2DQ", "VCVTPS2PD", "VCVTPS2PH", "VCVTPS2QQ", 
                      "VCVTPS2UDQ", "VCVTPS2UQQ", "VCVTQQ2PD", "VCVTQQ2PH", 
                      "VCVTQQ2PS", "VCVTSD2SH", "VCVTSD2SI", "VCVTSD2SS", 
                      "VCVTSD2USI", "VCVTSH2SD", "VCVTSH2SI", "VCVTSH2SS", 
                      "VCVTSH2USI", "VCVTSI2SD", "VCVTSI2SH", "VCVTSI2SS", 
                      "VCVTSS2SD", "VCVTSS2SH", "VCVTSS2SI", "VCVTSS2USI", 
                      "VCVTTPD2DQ", "VCVTTPD2QQ", "VCVTTPD2UDQ", "VCVTTPD2UQQ", 
                      "VCVTTPH2DQ", "VCVTTPH2QQ", "VCVTTPH2UDQ", "VCVTTPH2UQQ", 
                      "VCVTTPH2UW", "VCVTTPH2W", "VCVTTPS2DQ", "VCVTTPS2QQ", 
                      "VCVTTPS2UDQ", "VCVTTPS2UQQ", "VCVTTSD2SI", "VCVTTSD2USI", 
                      "VCVTTSH2SI", "VCVTTSH2USI", "VCVTTSS2SI", "VCVTTSS2USI", 
                      "VCVTUDQ2PD", "VCVTUDQ2PH", "VCVTUDQ2PS", "VCVTUQQ2PD", 
                      "VCVTUQQ2PH", "VCVTUQQ2PS", "VCVTUSI2SD", "VCVTUSI2SH", 
                      "VCVTUSI2SS", "VCVTUW2PH", "VCVTW2PH", "VDBPSADBW", 
                      "VDIVPD", "VDIVPH", "VDIVPS", "VDIVSD", "VDIVSH", 
                      "VDIVSS", "VDPBF16PS", "VDPPD", "VDPPS", "VENDSCALEPH", 
                      "VENDSCALESH", "VEXP2PD", "VEXP2PS", "VEXPANDPD", 
                      "VEXPANDPS", "VEXTRACTF128", "VEXTRACTF32X4", "VEXTRACTF32X8", 
                      "VEXTRACTF64X2", "VEXTRACTF64X4", "VEXTRACTI128", 
                      "VEXTRACTI32X4", "VEXTRACTI32X8", "VEXTRACTI64X2", 
                      "VEXTRACTI64X4", "VEXTRACTPS", "VFCMADDCPH", "VFCMADDCSH", 
                      "VFCMULCPCH", "VFCMULCSH", "VFIXUPIMMPD", "VFIXUPIMMPS", 
                      "VFIXUPIMMSD", "VFIXUPIMMSS", "VFMADD123PD", "VFMADD123PS", 
                      "VFMADD123SD", "VFMADD123SS", "VFMADD132PD", "VFMADD132PH", 
                      "VFMADD132PS", "VFMADD132SD", "VFMADD132SS", "VFMADD213PD", 
                      "VFMADD213PH", "VFMADD213PS", "VFMADD213SD", "VFMADD213SS", 
                      "VFMADD231PD", "VFMADD231PH", "VFMADD231PS", "VFMADD231SD", 
                      "VFMADD231SS", "VFMADD312PD", "VFMADD312PS", "VFMADD312SD", 
                      "VFMADD312SS", "VFMADD321PD", "VFMADD321PS", "VFMADD321SD", 
                      "VFMADD321SS", "VFMADDCPH", "VFMADDCSH", "VFMADDPD", 
                      "VFMADDPS", "VFMADDSD", "VFMADDSS", "VFMADDSUB123PD", 
                      "VFMADDSUB123PS", "VFMADDSUB132PD", "VFMADDSUB132PH", 
                      "VFMADDSUB132PS", "VFMADDSUB213PD", "VFMADDSUB213PH", 
                      "VFMADDSUB213PS", "VFMADDSUB231PD", "VFMADDSUB231PH", 
                      "VFMADDSUB231PS", "VFMADDSUB312PD", "VFMADDSUB312PS", 
                      "VFMADDSUB321PD", "VFMADDSUB321PS", "VFMADDSUBPD", 
                      "VFMADDSUBPS", "VFMSUB123PD", "VFMSUB123PS", "VFMSUB123SD", 
                      "VFMSUB123SS", "VFMSUB132PD", "VFMSUB132PH", "VFMSUB132PS", 
                      "VFMSUB132SD", "VFMSUB132SS", "VFMSUB213PD", "VFMSUB213PH", 
                      "VFMSUB213PS", "VFMSUB213SD", "VFMSUB213SS", "VFMSUB231PD", 
                      "VFMSUB231PH", "VFMSUB231PS", "VFMSUB231SD", "VFMSUB231SS", 
                      "VFMSUB312PD", "VFMSUB312PS", "VFMSUB312SD", "VFMSUB312SS", 
                      "VFMSUB321PD", "VFMSUB321PS", "VFMSUB321SD", "VFMSUB321SS", 
                      "VFMSUBADD123PD", "VFMSUBADD123PS", "VFMSUBADD132PD", 
                      "VFMSUBADD132PH", "VFMSUBADD132PS", "VFMSUBADD213PD", 
                      "VFMSUBADD213PH", "VFMSUBADD213PS", "VFMSUBADD231PD", 
                      "VFMSUBADD231PH", "VFMSUBADD231PS", "VFMSUBADD312PD", 
                      "VFMSUBADD312PS", "VFMSUBADD321PD", "VFMSUBADD321PS", 
                      "VFMSUBADDPD", "VFMSUBADDPS", "VFMSUBPD", "VFMSUBPS", 
                      "VFMSUBSD", "VFMSUBSS", "VFMULCPCH", "VFMULCSH", "VFNMADD123PD", 
                      "VFNMADD123PS", "VFNMADD123SD", "VFNMADD123SS", "VFNMADD132PD", 
                      "VFNMADD132PS", "VFNMADD132SD", "VFNMADD132SS", "VFNMADD213PD", 
                      "VFNMADD213PS", "VFNMADD213SD", "VFNMADD213SS", "VFNMADD231PD", 
                      "VFNMADD231PS", "VFNMADD231SD", "VFNMADD231SS", "VFNMADD312PD", 
                      "VFNMADD312PS", "VFNMADD312SD", "VFNMADD312SS", "VFNMADD321PD", 
                      "VFNMADD321PS", "VFNMADD321SD", "VFNMADD321SS", "VFNMADDPD", 
                      "VFNMADDPS", "VFNMADDSD", "VFNMADDSS", "VFNMSUB123PD", 
                      "VFNMSUB123PS", "VFNMSUB123SD", "VFNMSUB123SS", "VFNMSUB132PD", 
                      "VFNMSUB132PS", "VFNMSUB132SD", "VFNMSUB132SS", "VFNMSUB213PD", 
                      "VFNMSUB213PS", "VFNMSUB213SD", "VFNMSUB213SS", "VFNMSUB231PD", 
                      "VFNMSUB231PS", "VFNMSUB231SD", "VFNMSUB231SS", "VFNMSUB312PD", 
                      "VFNMSUB312PS", "VFNMSUB312SD", "VFNMSUB312SS", "VFNMSUB321PD", 
                      "VFNMSUB321PS", "VFNMSUB321SD", "VFNMSUB321SS", "VFNMSUBPD", 
                      "VFNMSUBPS", "VFNMSUBSD", "VFNMSUBSS", "VFPCLASSPD", 
                      "VFPCLASSPH", "VFPCLASSPS", "VFPCLASSSD", "VFPCLASSSH", 
                      "VFPCLASSSS", "VFRCZPD", "VFRCZPS", "VFRCZSD", "VFRCZSS", 
                      "VGATHERDPD", "VGATHERDPS", "VGATHERPF0DPD", "VGATHERPF0DPS", 
                      "VGATHERPF0QPD", "VGATHERPF0QPS", "VGATHERPF1DPD", 
                      "VGATHERPF1DPS", "VGATHERPF1QPD", "VGATHERPF1QPS", 
                      "VGATHERQPD", "VGATHERQPS", "VGETEXPPD", "VGETEXPPH", 
                      "VGETEXPPS", "VGETEXPSD", "VGETEXPSH", "VGETEXPSS", 
                      "VGETMANTPD", "VGETMANTPH", "VGETMANTPS", "VGETMANTSD", 
                      "VGETMANTSH", "VGETMANTSS", "VGETMAXPH", "VGETMAXSH", 
                      "VGETMINPH", "VGETMINSH", "VGF2P8AFFINEINVQB", "VGF2P8AFFINEQB", 
                      "VGF2P8MULB", "VHADDPD", "VHADDPS", "VHSUBPD", "VHSUBPS", 
                      "VINSERTF128", "VINSERTF32X4", "VINSERTF32X8", "VINSERTF64X2", 
                      "VINSERTF64X4", "VINSERTI128", "VINSERTI32X4", "VINSERTI32X8", 
                      "VINSERTI64X2", "VINSERTI64X4", "VINSERTPS", "VLDDQU", 
                      "VLDMXCSR", "VLDQQU", "VMASKMOVDQU", "VMASKMOVPD", 
                      "VMASKMOVPS", "VMAXPD", "VMAXPS", "VMAXSD", "VMAXSS", 
                      "VMCALL", "VMCLEAR", "VMFUNC", "VMGEXIT", "VMINPD", 
                      "VMINPS", "VMINSD", "VMINSS", "VMLAUNCH", "VMLOAD", 
                      "VMMCALL", "VMOVAPD", "VMOVAPS", "VMOVD", "VMOVDDUP", 
                      "VMOVDQA", "VMOVDQA32", "VMOVDQA64", "VMOVDQU", "VMOVDQU16", 
                      "VMOVDQU32", "VMOVDQU64", "VMOVDQU8", "VMOVHLPS", 
                      "VMOVHPD", "VMOVHPS", "VMOVLHPS", "VMOVLPD", "VMOVLPS", 
                      "VMOVMSKPD", "VMOVMSKPS", "VMOVNTDQ", "VMOVNTDQA", 
                      "VMOVNTPD", "VMOVNTPS", "VMOVNTQQ", "VMOVQ", "VMOVQQA", 
                      "VMOVQQU", "VMOVSD", "VMOVSH", "VMOVSHDUP", "VMOVSLDUP", 
                      "VMOVSS", "VMOVUPD", "VMOVUPS", "VMOVW", "VMPSADBW", 
                      "VMPTRLD", "VMPTRST", "VMREAD", "VMRESUME", "VMRUN", 
                      "VMSAVE", "VMULPD", "VMULPH", "VMULPS", "VMULSD", 
                      "VMULSH", "VMULSS", "VMWRITE", "VMXOFF", "VMXON", 
                      "VORPD", "VORPS", "VP2INTERSECTD", "VPABSB", "VPABSD", 
                      "VPABSQ", "VPABSW", "VPACKSSDW", "VPACKSSWB", "VPACKUSDW", 
                      "VPACKUSWB", "VPADDB", "VPADDD", "VPADDQ", "VPADDSB", 
                      "VPADDSW", "VPADDUSB", "VPADDUSW", "VPADDW", "VPALIGNR", 
                      "VPAND", "VPANDD", "VPANDN", "VPANDND", "VPANDNQ", 
                      "VPANDQ", "VPAVGB", "VPAVGW", "VPBLENDD", "VPBLENDMB", 
                      "VPBLENDMD", "VPBLENDMQ", "VPBLENDMW", "VPBLENDVB", 
                      "VPBLENDW", "VPBROADCASTB", "VPBROADCASTD", "VPBROADCASTMB2Q", 
                      "VPBROADCASTMW2D", "VPBROADCASTQ", "VPBROADCASTW", 
                      "VPCLMULHQHQDQ", "VPCLMULHQLQDQ", "VPCLMULLQHQDQ", 
                      "VPCLMULLQLQDQ", "VPCLMULQDQ", "VPCMOV", "VPCMPB", 
                      "VPCMPD", "VPCMPEQB", "VPCMPEQD", "VPCMPEQQ", "VPCMPEQUB", 
                      "VPCMPEQUD", "VPCMPEQUQ", "VPCMPEQUW", "VPCMPEQW", 
                      "VPCMPESTRI", "VPCMPESTRM", "VPCMPGEB", "VPCMPGED", 
                      "VPCMPGEQ", "VPCMPGEUB", "VPCMPGEUD", "VPCMPGEUQ", 
                      "VPCMPGEUW", "VPCMPGEW", "VPCMPGTB", "VPCMPGTD", "VPCMPGTQ", 
                      "VPCMPGTUB", "VPCMPGTUD", "VPCMPGTUQ", "VPCMPGTUW", 
                      "VPCMPGTW", "VPCMPISTRI", "VPCMPISTRM", "VPCMPLEB", 
                      "VPCMPLED", "VPCMPLEQ", "VPCMPLEUB", "VPCMPLEUD", 
                      "VPCMPLEUQ", "VPCMPLEUW", "VPCMPLEW", "VPCMPLTB", 
                      "VPCMPLTD", "VPCMPLTQ", "VPCMPLTUB", "VPCMPLTUD", 
                      "VPCMPLTUQ", "VPCMPLTUW", "VPCMPLTW", "VPCMPNEQB", 
                      "VPCMPNEQD", "VPCMPNEQQ", "VPCMPNEQUB", "VPCMPNEQUD", 
                      "VPCMPNEQUQ", "VPCMPNEQUW", "VPCMPNEQW", "VPCMPNGTB", 
                      "VPCMPNGTD", "VPCMPNGTQ", "VPCMPNGTUB", "VPCMPNGTUD", 
                      "VPCMPNGTUQ", "VPCMPNGTUW", "VPCMPNGTW", "VPCMPNLEB", 
                      "VPCMPNLED", "VPCMPNLEQ", "VPCMPNLEUB", "VPCMPNLEUD", 
                      "VPCMPNLEUQ", "VPCMPNLEUW", "VPCMPNLEW", "VPCMPNLTB", 
                      "VPCMPNLTD", "VPCMPNLTQ", "VPCMPNLTUB", "VPCMPNLTUD", 
                      "VPCMPNLTUQ", "VPCMPNLTUW", "VPCMPNLTW", "VPCMPQ", 
                      "VPCMPUB", "VPCMPUD", "VPCMPUQ", "VPCMPUW", "VPCMPW", 
                      "VPCOMB", "VPCOMD", "VPCOMPRESSB", "VPCOMPRESSD", 
                      "VPCOMPRESSQ", "VPCOMPRESSW", "VPCOMQ", "VPCOMUB", 
                      "VPCOMUD", "VPCOMUQ", "VPCOMUW", "VPCOMW", "VPCONFLICTD", 
                      "VPCONFLICTQ", "VPDPBSSD", "VPDPBSSDS", "VPDPBSUD", 
                      "VPDPBSUDS", "VPDPBUSD", "VPDPBUSDS", "VPDPBUUD", 
                      "VPDPBUUDS", "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", "VPEXTRB", "VPEXTRD", "VPEXTRQ", 
                      "VPEXTRW", "VPGATHERDD", "VPGATHERDQ", "VPGATHERQD", 
                      "VPGATHERQQ", "VPHADDBD", "VPHADDBQ", "VPHADDBW", 
                      "VPHADDD", "VPHADDDQ", "VPHADDSW", "VPHADDUBD", "VPHADDUBQ", 
                      "VPHADDUBW", "VPHADDUDQ", "VPHADDUWD", "VPHADDUWQ", 
                      "VPHADDW", "VPHADDWD", "VPHADDWQ", "VPHMINPOSUW", 
                      "VPHSUBBW", "VPHSUBD", "VPHSUBDQ", "VPHSUBSW", "VPHSUBW", 
                      "VPHSUBWD", "VPINSRB", "VPINSRD", "VPINSRQ", "VPINSRW", 
                      "VPLZCNTD", "VPLZCNTQ", "VPMACSDD", "VPMACSDQH", "VPMACSDQL", 
                      "VPMACSSDD", "VPMACSSDQH", "VPMACSSDQL", "VPMACSSWD", 
                      "VPMACSSWW", "VPMACSWD", "VPMACSWW", "VPMADCSSWD", 
                      "VPMADCSWD", "VPMADD132PH", "VPMADD132SH", "VPMADD213PH", 
                      "VPMADD213SH", "VPMADD231PH", "VPMADD231SH", "VPMADD52HUQ", 
                      "VPMADD52LUQ", "VPMADDUBSW", "VPMADDWD", "VPMASKMOVD", 
                      "VPMASKMOVQ", "VPMAXSB", "VPMAXSD", "VPMAXSQ", "VPMAXSW", 
                      "VPMAXUB", "VPMAXUD", "VPMAXUQ", "VPMAXUW", "VPMINSB", 
                      "VPMINSD", "VPMINSQ", "VPMINSW", "VPMINUB", "VPMINUD", 
                      "VPMINUQ", "VPMINUW", "VPMOVB2M", "VPMOVD2M", "VPMOVDB", 
                      "VPMOVDW", "VPMOVM2B", "VPMOVM2D", "VPMOVM2Q", "VPMOVM2W", 
                      "VPMOVMSKB", "VPMOVQ2M", "VPMOVQB", "VPMOVQD", "VPMOVQW", 
                      "VPMOVSDB", "VPMOVSDW", "VPMOVSQB", "VPMOVSQD", "VPMOVSQW", 
                      "VPMOVSWB", "VPMOVSXBD", "VPMOVSXBQ", "VPMOVSXBW", 
                      "VPMOVSXDQ", "VPMOVSXWD", "VPMOVSXWQ", "VPMOVUSDB", 
                      "VPMOVUSDW", "VPMOVUSQB", "VPMOVUSQD", "VPMOVUSQW", 
                      "VPMOVUSWB", "VPMOVW2M", "VPMOVWB", "VPMOVZXBD", "VPMOVZXBQ", 
                      "VPMOVZXBW", "VPMOVZXDQ", "VPMOVZXWD", "VPMOVZXWQ", 
                      "VPMSUB132PH", "VPMSUB132SH", "VPMSUB213PH", "VPMSUB213SH", 
                      "VPMSUB231PH", "VPMSUB231SH", "VPMULDQ", "VPMULHRSW", 
                      "VPMULHUW", "VPMULHW", "VPMULLD", "VPMULLQ", "VPMULLW", 
                      "VPMULTISHIFTQB", "VPMULUDQ", "VPNMADD132SH", "VPNMADD213SH", 
                      "VPNMADD231SH", "VPNMSUB132SH", "VPNMSUB213SH", "VPNMSUB231SH", 
                      "VPOPCNTB", "VPOPCNTD", "VPOPCNTQ", "VPOPCNTW", "VPOR", 
                      "VPORD", "VPORQ", "VPPERM", "VPROLD", "VPROLQ", "VPROLVD", 
                      "VPROLVQ", "VPRORD", "VPRORQ", "VPRORVD", "VPRORVQ", 
                      "VPROTB", "VPROTD", "VPROTQ", "VPROTW", "VPSADBW", 
                      "VPSCATTERDD", "VPSCATTERDQ", "VPSCATTERQD", "VPSCATTERQQ", 
                      "VPSHAB", "VPSHAD", "VPSHAQ", "VPSHAW", "VPSHLB", 
                      "VPSHLD", "VPSHLDD", "VPSHLDQ", "VPSHLDVD", "VPSHLDVQ", 
                      "VPSHLDVW", "VPSHLDW", "VPSHLQ", "VPSHLW", "VPSHRDD", 
                      "VPSHRDQ", "VPSHRDVD", "VPSHRDVQ", "VPSHRDVW", "VPSHRDW", 
                      "VPSHUFB", "VPSHUFBITQMB", "VPSHUFD", "VPSHUFHW", 
                      "VPSHUFLW", "VPSIGNB", "VPSIGND", "VPSIGNW", "VPSLLD", 
                      "VPSLLDQ", "VPSLLQ", "VPSLLVD", "VPSLLVQ", "VPSLLVW", 
                      "VPSLLW", "VPSRAD", "VPSRAQ", "VPSRAVD", "VPSRAVQ", 
                      "VPSRAVW", "VPSRAW", "VPSRLD", "VPSRLDQ", "VPSRLQ", 
                      "VPSRLVD", "VPSRLVQ", "VPSRLVW", "VPSRLW", "VPSUBB", 
                      "VPSUBD", "VPSUBQ", "VPSUBSB", "VPSUBSW", "VPSUBUSB", 
                      "VPSUBUSW", "VPSUBW", "VPTERNLOGD", "VPTERNLOGQ", 
                      "VPTEST", "VPTESTMB", "VPTESTMD", "VPTESTMQ", "VPTESTMW", 
                      "VPTESTNMB", "VPTESTNMD", "VPTESTNMQ", "VPTESTNMW", 
                      "VPUNPCKHBW", "VPUNPCKHDQ", "VPUNPCKHQDQ", "VPUNPCKHWD", 
                      "VPUNPCKLBW", "VPUNPCKLDQ", "VPUNPCKLQDQ", "VPUNPCKLWD", 
                      "VPXOR", "VPXORD", "VPXORQ", "VRANGEPD", "VRANGEPS", 
                      "VRANGESD", "VRANGESS", "VRCP14PD", "VRCP14PS", "VRCP14SD", 
                      "VRCP14SS", "VRCP28PD", "VRCP28PS", "VRCP28SD", "VRCP28SS", 
                      "VRCPPH", "VRCPPS", "VRCPSH", "VRCPSS", "VREDUCEPD", 
                      "VREDUCEPH", "VREDUCEPS", "VREDUCESD", "VREDUCESH", 
                      "VREDUCESS", "VRNDSCALEPD", "VRNDSCALEPS", "VRNDSCALESD", 
                      "VRNDSCALESS", "VROUNDPD", "VROUNDPS", "VROUNDSD", 
                      "VROUNDSS", "VRSQRT14PD", "VRSQRT14PS", "VRSQRT14SD", 
                      "VRSQRT14SS", "VRSQRT28PD", "VRSQRT28PS", "VRSQRT28SD", 
                      "VRSQRT28SS", "VRSQRTPH", "VRSQRTPS", "VRSQRTSH", 
                      "VRSQRTSS", "VSCALEFPD", "VSCALEFPH", "VSCALEFPS", 
                      "VSCALEFSD", "VSCALEFSH", "VSCALEFSS", "VSCATTERDPD", 
                      "VSCATTERDPS", "VSCATTERPF0DPD", "VSCATTERPF0DPS", 
                      "VSCATTERPF0QPD", "VSCATTERPF0QPS", "VSCATTERPF1DPD", 
                      "VSCATTERPF1DPS", "VSCATTERPF1QPD", "VSCATTERPF1QPS", 
                      "VSCATTERQPD", "VSCATTERQPS", "VSHUFF32X4", "VSHUFF64X2", 
                      "VSHUFI32X4", "VSHUFI64X2", "VSHUFPD", "VSHUFPS", 
                      "VSQRTPD", "VSQRTPH", "VSQRTPS", "VSQRTSD", "VSQRTSH", 
                      "VSQRTSS", "VSTMXCSR", "VSUBPD", "VSUBPH", "VSUBPS", 
                      "VSUBSD", "VSUBSH", "VSUBSS", "VTESTPD", "VTESTPS", 
                      "VUCOMISD", "VUCOMISH", "VUCOMISS", "VUNPCKHPD", "VUNPCKHPS", 
                      "VUNPCKLPD", "VUNPCKLPS", "VXORPD", "VXORPS", "VZEROALL", 
                      "VZEROUPPER", "WBNOINVD", "WRFSBASE", "WRGSBASE", 
                      "WRMSRLIST", "WRMSRNS", "WRPKRU", "WRSSD", "WRSSQ", 
                      "WRUSSD", "WRUSSQ", "XABORT", "XBEGIN", "XCRYPTCBC", 
                      "XCRYPTCFB", "XCRYPTCTR", "XCRYPTECB", "XCRYPTOFB", 
                      "XEND", "XGETBV", "XORPD", "XORPS", "XRESLDTRK", "XRSTOR", 
                      "XRSTOR64", "XRSTORS", "XRSTORS64", "XSAVE", "XSAVE64", 
                      "XSAVEC", "XSAVEC64", "XSAVEOPT", "XSAVEOPT64", "XSAVES", 
                      "XSAVES64", "XSETBV", "XSHA1", "XSHA256", "XSTORE", 
                      "XSUSLDTRK", "XTEST", "BITS", "USE16", "USE32", "DEFAULT", 
                      "REL", "ABS", "BND", "NOBND", "SECTIONS", "SECTION", 
                      "SEGMENTS", "SEGMENT", "ABSOLUTE", "EXTERN", "REQUIRED", 
                      "GLOBAL", "COMMON", "NEAR", "FAR", "STATIC", "CPU", 
                      "FLOAT_NAME", "DAZ", "NODAZ", "UP", "DOWN", "ZERO", 
                      "WARNING", "ORG", "ALIGN", "VSTART", "START", "PROGBITS", 
                      "NOBITS", "VFOLLOWS", "FOLLOWS", "MAP", "ALL", "BRIEF", 
                      "SYMBOLS", "PRIVATE", "PUBLIC", "STACK", "CLASS_", 
                      "OVERLAY", "FLAT", "GROUP", "UPPERCASE", "IMPORT", 
                      "EXPORT", "RESIDENT", "NODATA", "PARM", "CODE", "TEXT", 
                      "RDATA", "DATA", "BSS", "INFO", "COMDAT", "SAFESEH", 
                      "MIXED", "ZEROFILL", "NO_DEAD_STRIP", "LIVE_SUPPORT", 
                      "STRIP_STATIC_SYMS", "DEBUG", "OSABI", "NOTE", "PREINIT_ARRAY", 
                      "INIT_ARRAY", "FINI_ARRAY", "TLS", "POINTER", "NOALLOC", 
                      "ALLOC", "NOEXEC", "EXEC", "NOWRITE", "WRITE", "WRT", 
                      "FUNCTION", "OBJECT", "WEAK", "STRONG", "INTERNAL", 
                      "HIDDEN_", "PROTECTED", "STRICT", "TIMES", "FLOAT_NUMBER", 
                      "DECIMAL_INTEGER", "SIGN", "OCT_INTEGER", "HEX_INTEGER", 
                      "BIN_INTEGER", "STRING", "STRING1", "STRING2", "WARNING_NAME", 
                      "NAME", "PREPROCESSOR_DIRECTIVES", "MULTILINE_MACRO", 
                      "COMMENT", "EOL", "WHITESPACE" ]

    RULE_program = 0
    RULE_line = 1
    RULE_label = 2
    RULE_directive = 3
    RULE_bits = 4
    RULE_decimal_integer = 5
    RULE_use16 = 6
    RULE_use32 = 7
    RULE_default = 8
    RULE_default_perfix = 9
    RULE_section = 10
    RULE_section_params = 11
    RULE_name = 12
    RULE_attribute = 13
    RULE_section_type = 14
    RULE_class = 15
    RULE_overlay = 16
    RULE_designation = 17
    RULE_allocation = 18
    RULE_execution = 19
    RULE_writing = 20
    RULE_starting_possition = 21
    RULE_follow = 22
    RULE_flat = 23
    RULE_absolute_seg = 24
    RULE_alingment = 25
    RULE_comdat = 26
    RULE_tls = 27
    RULE_absolute = 28
    RULE_integer = 29
    RULE_extern = 30
    RULE_extern_params = 31
    RULE_wrt = 32
    RULE_weak = 33
    RULE_required = 34
    RULE_global = 35
    RULE_global_params = 36
    RULE_global_type = 37
    RULE_visibility = 38
    RULE_binding = 39
    RULE_common = 40
    RULE_common_params = 41
    RULE_near = 42
    RULE_far = 43
    RULE_static = 44
    RULE_cpu = 45
    RULE_float_name = 46
    RULE_float_params = 47
    RULE_warning = 48
    RULE_warning_state = 49
    RULE_warning_class = 50
    RULE_warning_name = 51
    RULE_push = 52
    RULE_pop = 53
    RULE_org = 54
    RULE_map = 55
    RULE_map_type = 56
    RULE_group = 57
    RULE_uppercase = 58
    RULE_import_rule = 59
    RULE_export = 60
    RULE_export_params = 61
    RULE_resident = 62
    RULE_nodata = 63
    RULE_parm = 64
    RULE_safeseh = 65
    RULE_osabi = 66
    RULE_times_prefix = 67
    RULE_times = 68
    RULE_pseudoinstruction = 69
    RULE_dx = 70
    RULE_float_number = 71
    RULE_question = 72
    RULE_resx = 73
    RULE_incbin = 74
    RULE_string = 75
    RULE_value = 76
    RULE_atom = 77
    RULE_size = 78
    RULE_list = 79
    RULE_duplist = 80
    RULE_parlist = 81
    RULE_unaryExpression = 82
    RULE_unaryOperator = 83
    RULE_castExpression = 84
    RULE_multiplicativeExpression = 85
    RULE_additiveExpression = 86
    RULE_shiftExpression = 87
    RULE_relationalExpression = 88
    RULE_equalityExpression = 89
    RULE_andExpression = 90
    RULE_exclusiveOrExpression = 91
    RULE_inclusiveOrExpression = 92
    RULE_booleanAndExpression = 93
    RULE_booleanOrExpression = 94
    RULE_conditionalExpression = 95
    RULE_expression = 96
    RULE_equ = 97
    RULE_instruction = 98
    RULE_opcode = 99
    RULE_operand = 100
    RULE_register = 101
    RULE_strict = 102
    RULE_macro_call = 103
    RULE_macro_param = 104

    ruleNames =  [ "program", "line", "label", "directive", "bits", "decimal_integer", 
                   "use16", "use32", "default", "default_perfix", "section", 
                   "section_params", "name", "attribute", "section_type", 
                   "class", "overlay", "designation", "allocation", "execution", 
                   "writing", "starting_possition", "follow", "flat", "absolute_seg", 
                   "alingment", "comdat", "tls", "absolute", "integer", 
                   "extern", "extern_params", "wrt", "weak", "required", 
                   "global", "global_params", "global_type", "visibility", 
                   "binding", "common", "common_params", "near", "far", 
                   "static", "cpu", "float_name", "float_params", "warning", 
                   "warning_state", "warning_class", "warning_name", "push", 
                   "pop", "org", "map", "map_type", "group", "uppercase", 
                   "import_rule", "export", "export_params", "resident", 
                   "nodata", "parm", "safeseh", "osabi", "times_prefix", 
                   "times", "pseudoinstruction", "dx", "float_number", "question", 
                   "resx", "incbin", "string", "value", "atom", "size", 
                   "list", "duplist", "parlist", "unaryExpression", "unaryOperator", 
                   "castExpression", "multiplicativeExpression", "additiveExpression", 
                   "shiftExpression", "relationalExpression", "equalityExpression", 
                   "andExpression", "exclusiveOrExpression", "inclusiveOrExpression", 
                   "booleanAndExpression", "booleanOrExpression", "conditionalExpression", 
                   "expression", "equ", "instruction", "opcode", "operand", 
                   "register", "strict", "macro_call", "macro_param" ]

    EOF = Token.EOF
    DB=1
    DW=2
    DD=3
    DQ=4
    DT=5
    DO=6
    DY=7
    DZ=8
    RESB=9
    RESW=10
    RESD=11
    RESQ=12
    REST=13
    RESO=14
    RESY=15
    RESZ=16
    INCBIN=17
    BYTE=18
    WORD=19
    DWORD=20
    QWORD=21
    TWORD=22
    OWORD=23
    YWORD=24
    ZWORD=25
    DUP=26
    COMMA=27
    QUESTION=28
    LEFT_PARENTHESIS=29
    RIGHT_PARENTHESIS=30
    LEFT_BRACKET=31
    RIGHT_BRACKET=32
    COLON=33
    BOOLEAN_OR=34
    BOOLEAN_XOR=35
    BOOLEAN_AND=36
    EQUAL_1=37
    EQUAL_2=38
    NOT_EQUAL_1=39
    NOT_EQUAL_2=40
    LESS_THAN=41
    LESS_THAN_EQUAL=42
    GREATER_THAN=43
    GREATER_THAN_EQUAL=44
    SIGNED_COMPARISON=45
    BITWISE_OR=46
    BITWISE_XOR=47
    BITWISE_AND=48
    LEFT_SHIFT=49
    RIGHT_SHIFT=50
    LEFT_SHIFT_COMPLETENESS=51
    RIGHT_SHIFT_COMPLETENESS=52
    PLUS=53
    MINUS=54
    MULTIPLICATION=55
    UNSIGNED_DIVISION=56
    SIGNED_DIVISION=57
    PERCENT=58
    SIGNED_MODULE=59
    BITWISE_NOT=60
    BOOLEAN_NOT=61
    DOLLAR=62
    DOUBLE_DOLLAR=63
    AAA=64
    AAD=65
    AAM=66
    AAS=67
    ADC=68
    ADD=69
    AND=70
    ARPL=71
    BB0_RESET=72
    BB1_RESET=73
    BOUND=74
    BSF=75
    BSR=76
    BSWAP=77
    BT=78
    BTC=79
    BTR=80
    BTS=81
    CALL=82
    CBW=83
    CDQ=84
    CDQE=85
    CLC=86
    CLD=87
    CLI=88
    CLTS=89
    CMC=90
    CMOVA=91
    CMOVAE=92
    CMOVB=93
    CMOVBE=94
    CMOVC=95
    CMOVE=96
    CMOVG=97
    CMOVGE=98
    CMOVL=99
    CMOVLE=100
    CMOVNA=101
    CMOVNAE=102
    CMOVNB=103
    CMOVNBE=104
    CMOVNC=105
    CMOVNE=106
    CMOVNG=107
    CMOVNGE=108
    CMOVNL=109
    CMOVNO=110
    CMOVNP=111
    CMOVNS=112
    CMOVNZ=113
    CMOVO=114
    CMOVP=115
    CMOVPE=116
    CMOVPO=117
    CMOVS=118
    CMOVZ=119
    CMP=120
    CMPSB=121
    CMPSD=122
    CMPSQ=123
    CMPSW=124
    CMPXCHG=125
    CMPXCHG16B=126
    CMPXCHG486=127
    CMPXCHG8B=128
    CPU_READ=129
    CPU_WRITE=130
    CPUID=131
    CQO=132
    CWD=133
    CWDE=134
    DAA=135
    DAS=136
    DEC=137
    DIV=138
    DMINT=139
    EMMS=140
    ENTER=141
    EQU=142
    F2XM1=143
    FABS=144
    FADD=145
    FADDP=146
    FBLD=147
    FBSTP=148
    FCHS=149
    FCLEX=150
    FCMOVB=151
    FCMOVBE=152
    FCMOVE=153
    FCMOVNB=154
    FCMOVNBE=155
    FCMOVNE=156
    FCMOVNU=157
    FCMOVU=158
    FCOM=159
    FCOMI=160
    FCOMIP=161
    FCOMP=162
    FCOMPP=163
    FCOS=164
    FDECSTP=165
    FDISI=166
    FDIV=167
    FDIVP=168
    FDIVR=169
    FDIVRP=170
    FEMMS=171
    FENI=172
    FFREE=173
    FFREEP=174
    FIADD=175
    FICOM=176
    FICOMP=177
    FIDIV=178
    FIDIVR=179
    FILD=180
    FIMUL=181
    FINCSTP=182
    FINIT=183
    FIST=184
    FISTP=185
    FISTTP=186
    FISUB=187
    FISUBR=188
    FLD=189
    FLD1=190
    FLDCW=191
    FLDENV=192
    FLDL2E=193
    FLDL2T=194
    FLDLG2=195
    FLDLN2=196
    FLDPI=197
    FLDZ=198
    FMUL=199
    FMULP=200
    FNCLEX=201
    FNDISI=202
    FNENI=203
    FNINIT=204
    FNOP=205
    FNSAVE=206
    FNSTCW=207
    FNSTENV=208
    FNSTSW=209
    FPATAN=210
    FPREM=211
    FPREM1=212
    FPTAN=213
    FRNDINT=214
    FRSTOR=215
    FSAVE=216
    FSCALE=217
    FSETPM=218
    FSIN=219
    FSINCOS=220
    FSQRT=221
    FST=222
    FSTCW=223
    FSTENV=224
    FSTP=225
    FSTSW=226
    FSUB=227
    FSUBP=228
    FSUBR=229
    FSUBRP=230
    FTST=231
    FUCOM=232
    FUCOMI=233
    FUCOMIP=234
    FUCOMP=235
    FUCOMPP=236
    FWAIT=237
    FXAM=238
    FXCH=239
    FXTRACT=240
    FYL2X=241
    FYL2XP1=242
    HLT=243
    IBTS=244
    ICEBP=245
    IDIV=246
    IMUL=247
    IN=248
    INC=249
    INSB=250
    INSD=251
    INSW=252
    INT=253
    INT01=254
    INT03=255
    INT1=256
    INT3=257
    INTO=258
    INVD=259
    INVLPG=260
    INVLPGA=261
    INVPCID=262
    IRET=263
    IRETD=264
    IRETQ=265
    IRETW=266
    JA=267
    JAE=268
    JB=269
    JBE=270
    JC=271
    JCXZ=272
    JE=273
    JECXZ=274
    JG=275
    JGE=276
    JL=277
    JLE=278
    JMP=279
    JMPE=280
    JNA=281
    JNAE=282
    JNB=283
    JNBE=284
    JNC=285
    JNE=286
    JNG=287
    JNGE=288
    JNL=289
    JNLE=290
    JNO=291
    JNP=292
    JNS=293
    JNZ=294
    JO=295
    JP=296
    JPE=297
    JPO=298
    JRCXZ=299
    JS=300
    JZ=301
    LAHF=302
    LAR=303
    LDS=304
    LEA=305
    LEAVE=306
    LES=307
    LFENCE=308
    LFS=309
    LGDT=310
    LGS=311
    LIDT=312
    LLDT=313
    LMSW=314
    LOADALL=315
    LOADALL286=316
    LODSB=317
    LODSD=318
    LODSQ=319
    LODSW=320
    LOOP=321
    LOOPE=322
    LOOPNE=323
    LOOPNZ=324
    LOOPZ=325
    LSL=326
    LSS=327
    LTR=328
    MFENCE=329
    MONITOR=330
    MONITORX=331
    MOV=332
    MOVD=333
    MOVQ=334
    MOVSB=335
    MOVSD=336
    MOVSQ=337
    MOVSW=338
    MOVSX=339
    MOVSXD=340
    MOVZX=341
    MUL=342
    MWAIT=343
    MWAITX=344
    NEG=345
    NOP=346
    NOT=347
    OR=348
    OUT=349
    OUTSB=350
    OUTSD=351
    OUTSW=352
    PACKSSDW=353
    PACKSSWB=354
    PACKUSWB=355
    PADDB=356
    PADDD=357
    PADDSB=358
    PADDSIW=359
    PADDSW=360
    PADDUSB=361
    PADDUSW=362
    PADDW=363
    PAND=364
    PANDN=365
    PAUSE=366
    PAVEB=367
    PAVGUSB=368
    PCMPEQB=369
    PCMPEQD=370
    PCMPEQW=371
    PCMPGTB=372
    PCMPGTD=373
    PCMPGTW=374
    PDISTIB=375
    PF2ID=376
    PFACC=377
    PFADD=378
    PFCMPEQ=379
    PFCMPGE=380
    PFCMPGT=381
    PFMAX=382
    PFMIN=383
    PFMUL=384
    PFRCP=385
    PFRCPIT1=386
    PFRCPIT2=387
    PFRSQIT1=388
    PFRSQRT=389
    PFSUB=390
    PFSUBR=391
    PI2FD=392
    PMACHRIW=393
    PMADDWD=394
    PMAGW=395
    PMULHRIW=396
    PMULHRWA=397
    PMULHRWC=398
    PMULHW=399
    PMULLW=400
    PMVGEZB=401
    PMVLZB=402
    PMVNZB=403
    PMVZB=404
    POP=405
    POPA=406
    POPAD=407
    POPAW=408
    POPF=409
    POPFD=410
    POPFQ=411
    POPFW=412
    POR=413
    PREFETCH=414
    PREFETCHW=415
    PSLLD=416
    PSLLQ=417
    PSLLW=418
    PSRAD=419
    PSRAW=420
    PSRLD=421
    PSRLQ=422
    PSRLW=423
    PSUBB=424
    PSUBD=425
    PSUBSB=426
    PSUBSIW=427
    PSUBSW=428
    PSUBUSB=429
    PSUBUSW=430
    PSUBW=431
    PUNPCKHBW=432
    PUNPCKHDQ=433
    PUNPCKHWD=434
    PUNPCKLBW=435
    PUNPCKLDQ=436
    PUNPCKLWD=437
    PUSH=438
    PUSHA=439
    PUSHAD=440
    PUSHAW=441
    PUSHF=442
    PUSHFD=443
    PUSHFQ=444
    PUSHFW=445
    PXOR=446
    RCL=447
    RCR=448
    RDM=449
    RDMSR=450
    RDPMC=451
    RDSHR=452
    RDTSC=453
    RDTSCP=454
    RET=455
    RETD=456
    RETF=457
    RETFD=458
    RETFQ=459
    RETFW=460
    RETN=461
    RETND=462
    RETNQ=463
    RETNW=464
    RETQ=465
    RETW=466
    ROL=467
    ROR=468
    RSDC=469
    RSLDT=470
    RSM=471
    RSTS=472
    SAHF=473
    SAL=474
    SALC=475
    SAR=476
    SBB=477
    SCASB=478
    SCASD=479
    SCASQ=480
    SCASW=481
    SETA=482
    SETAE=483
    SETB=484
    SETBE=485
    SETC=486
    SETE=487
    SETG=488
    SETGE=489
    SETL=490
    SETLE=491
    SETNA=492
    SETNAE=493
    SETNB=494
    SETNBE=495
    SETNC=496
    SETNE=497
    SETNG=498
    SETNGE=499
    SETNL=500
    SETNLE=501
    SETNO=502
    SETNP=503
    SETNS=504
    SETNZ=505
    SETO=506
    SETP=507
    SETPE=508
    SETPO=509
    SETS=510
    SETZ=511
    SFENCE=512
    SGDT=513
    SHL=514
    SHLD=515
    SHR=516
    SHRD=517
    SIDT=518
    SKINIT=519
    SLDT=520
    SMI=521
    SMINT=522
    SMINTOLD=523
    SMSW=524
    STC=525
    STD=526
    STI=527
    STOSB=528
    STOSD=529
    STOSQ=530
    STOSW=531
    STR=532
    SUB=533
    SVDC=534
    SVLDT=535
    SVTS=536
    SWAPGS=537
    SYSCALL=538
    SYSENTER=539
    SYSEXIT=540
    SYSRET=541
    TEST=542
    UD0=543
    UD1=544
    UD2=545
    UD2A=546
    UD2B=547
    UMOV=548
    VERR=549
    VERW=550
    WBINVD=551
    WRMSR=552
    WRSHR=553
    XADD=554
    XBTS=555
    XCHG=556
    XLAT=557
    XLATB=558
    XOR=559
    AL=560
    AH=561
    AX=562
    EAX=563
    RAX=564
    BL=565
    BH=566
    BX=567
    EBX=568
    RBX=569
    CL=570
    CH=571
    CX=572
    ECX=573
    RCX=574
    DL=575
    DH=576
    DX=577
    EDX=578
    RDX=579
    SPL=580
    SP=581
    ESP=582
    RSP=583
    BPL=584
    BP=585
    EBP=586
    RBP=587
    SIL=588
    SI=589
    ESI=590
    RSI=591
    DIL=592
    DI=593
    EDI=594
    RDI=595
    R8B=596
    R9B=597
    R10B=598
    R11B=599
    R12B=600
    R13B=601
    R14B=602
    R15B=603
    R8W=604
    R9W=605
    R10W=606
    R11W=607
    R12W=608
    R13W=609
    R14W=610
    R15W=611
    R8D=612
    R9D=613
    R10D=614
    R11D=615
    R12D=616
    R13D=617
    R14D=618
    R15D=619
    R8=620
    R9=621
    R10=622
    R11=623
    R12=624
    R13=625
    R14=626
    R15=627
    IP=628
    EIP=629
    RIP=630
    ES=631
    CS=632
    SS=633
    DS=634
    FS=635
    GS=636
    SEGR6=637
    SEGR7=638
    CR0=639
    CR1=640
    CR2=641
    CR3=642
    CR4=643
    CR5=644
    CR6=645
    CR7=646
    CR8=647
    CR9=648
    CR10=649
    CR11=650
    CR12=651
    CR13=652
    CR14=653
    CR15=654
    DR0=655
    DR1=656
    DR2=657
    DR3=658
    DR4=659
    DR5=660
    DR6=661
    DR7=662
    DR8=663
    DR9=664
    DR10=665
    DR11=666
    DR12=667
    DR13=668
    DR14=669
    DR15=670
    TR0=671
    TR1=672
    TR2=673
    TR3=674
    TR4=675
    TR5=676
    TR6=677
    TR7=678
    ST0=679
    ST1=680
    ST2=681
    ST3=682
    ST4=683
    ST5=684
    ST6=685
    ST7=686
    MM0=687
    MM1=688
    MM2=689
    MM3=690
    MM4=691
    MM5=692
    MM6=693
    MM7=694
    XMM0=695
    XMM1=696
    XMM2=697
    XMM3=698
    XMM4=699
    XMM5=700
    XMM6=701
    XMM7=702
    XMM8=703
    XMM9=704
    XMM10=705
    XMM11=706
    XMM12=707
    XMM13=708
    XMM14=709
    XMM15=710
    XMM16=711
    XMM17=712
    XMM18=713
    XMM19=714
    XMM20=715
    XMM21=716
    XMM22=717
    XMM23=718
    XMM24=719
    XMM25=720
    XMM26=721
    XMM27=722
    XMM28=723
    XMM29=724
    XMM30=725
    XMM31=726
    YMM0=727
    YMM1=728
    YMM2=729
    YMM3=730
    YMM4=731
    YMM5=732
    YMM6=733
    YMM7=734
    YMM8=735
    YMM9=736
    YMM10=737
    YMM11=738
    YMM12=739
    YMM13=740
    YMM14=741
    YMM15=742
    YMM16=743
    YMM17=744
    YMM18=745
    YMM19=746
    YMM20=747
    YMM21=748
    YMM22=749
    YMM23=750
    YMM24=751
    YMM25=752
    YMM26=753
    YMM27=754
    YMM28=755
    YMM29=756
    YMM30=757
    YMM31=758
    ZMM0=759
    ZMM1=760
    ZMM2=761
    ZMM3=762
    ZMM4=763
    ZMM5=764
    ZMM6=765
    ZMM7=766
    ZMM8=767
    ZMM9=768
    ZMM10=769
    ZMM11=770
    ZMM12=771
    ZMM13=772
    ZMM14=773
    ZMM15=774
    ZMM16=775
    ZMM17=776
    ZMM18=777
    ZMM19=778
    ZMM20=779
    ZMM21=780
    ZMM22=781
    ZMM23=782
    ZMM24=783
    ZMM25=784
    ZMM26=785
    ZMM27=786
    ZMM28=787
    ZMM29=788
    ZMM30=789
    ZMM31=790
    TMM0=791
    TMM1=792
    TMM2=793
    TMM3=794
    TMM4=795
    TMM5=796
    TMM6=797
    TMM7=798
    K0=799
    K1=800
    K2=801
    K3=802
    K4=803
    K5=804
    K6=805
    K7=806
    BND0=807
    BND1=808
    BND2=809
    BND3=810
    AADD=811
    AAND=812
    ADCX=813
    ADDPD=814
    ADDPS=815
    ADDSD=816
    ADDSS=817
    ADDSUBPD=818
    ADDSUBPS=819
    ADOX=820
    AESDEC=821
    AESDECLAST=822
    AESENC=823
    AESENCLAST=824
    AESIMC=825
    AESKEYGENASSIST=826
    ANDN=827
    ANDNPD=828
    ANDNPS=829
    ANDPD=830
    ANDPS=831
    AXOR=832
    BEXTR=833
    BLCFILL=834
    BLCI=835
    BLCIC=836
    BLCMSK=837
    BLCS=838
    BLENDPD=839
    BLENDPS=840
    BLENDVPD=841
    BLENDVPS=842
    BLSFILL=843
    BLSI=844
    BLSIC=845
    BLSMSK=846
    BLSR=847
    BNDCL=848
    BNDCN=849
    BNDCU=850
    BNDLDX=851
    BNDMK=852
    BNDMOV=853
    BNDSTX=854
    BZHI=855
    CLAC=856
    CLDEMOTE=857
    CLFLUSH=858
    CLFLUSHOPT=859
    CLGI=860
    CLRSSBSY=861
    CLUI=862
    CLWB=863
    CLZERO=864
    CMPEQPD=865
    CMPEQPS=866
    CMPEQSD=867
    CMPEQSS=868
    CMPLEPD=869
    CMPLEPS=870
    CMPLESD=871
    CMPLESS=872
    CMPLTPD=873
    CMPLTPS=874
    CMPLTSD=875
    CMPLTSS=876
    CMPNEQPD=877
    CMPNEQPS=878
    CMPNEQSD=879
    CMPNEQSS=880
    CMPNLEPD=881
    CMPNLEPS=882
    CMPNLESD=883
    CMPNLESS=884
    CMPNLTPD=885
    CMPNLTPS=886
    CMPNLTSD=887
    CMPNLTSS=888
    CMPNPXADD=889
    CMPNSXADD=890
    CMPNZXADD=891
    CMPORDPD=892
    CMPORDPS=893
    CMPORDSD=894
    CMPORDSS=895
    CMPOXADD=896
    CMPPD=897
    CMPPS=898
    CMPPXADD=899
    CMPSS=900
    CMPSXADD=901
    CMPUNORDPD=902
    CMPUNORDPS=903
    CMPUNORDSD=904
    CMPUNORDSS=905
    CMPZXADD=906
    COMISD=907
    COMISS=908
    CRC32=909
    CVTDQ2PD=910
    CVTDQ2PS=911
    CVTPD2DQ=912
    CVTPD2PI=913
    CVTPD2PS=914
    CVTPI2PD=915
    CVTPI2PS=916
    CVTPS2DQ=917
    CVTPS2PD=918
    CVTPS2PI=919
    CVTSD2SI=920
    CVTSD2SS=921
    CVTSI2SD=922
    CVTSI2SS=923
    CVTSS2SD=924
    CVTSS2SI=925
    CVTTPD2DQ=926
    CVTTPD2PI=927
    CVTTPS2DQ=928
    CVTTPS2PI=929
    CVTTSD2SI=930
    CVTTSS2SI=931
    DIVPD=932
    DIVPS=933
    DIVSD=934
    DIVSS=935
    DPPD=936
    DPPS=937
    ENCLS=938
    ENCLU=939
    ENCLV=940
    ENDBR32=941
    ENDBR64=942
    ENQCMD=943
    ENQCMDS=944
    EXTRACTPS=945
    EXTRQ=946
    FXRSTOR=947
    FXRSTOR64=948
    FXSAVE=949
    FXSAVE64=950
    GETSEC=951
    GF2P8AFFINEINVQB=952
    GF2P8AFFINEQB=953
    GF2P8MULB=954
    HADDPD=955
    HADDPS=956
    HINT_NOP0=957
    HINT_NOP1=958
    HINT_NOP10=959
    HINT_NOP11=960
    HINT_NOP12=961
    HINT_NOP13=962
    HINT_NOP14=963
    HINT_NOP15=964
    HINT_NOP16=965
    HINT_NOP17=966
    HINT_NOP18=967
    HINT_NOP19=968
    HINT_NOP2=969
    HINT_NOP20=970
    HINT_NOP21=971
    HINT_NOP22=972
    HINT_NOP23=973
    HINT_NOP24=974
    HINT_NOP25=975
    HINT_NOP26=976
    HINT_NOP27=977
    HINT_NOP28=978
    HINT_NOP29=979
    HINT_NOP3=980
    HINT_NOP30=981
    HINT_NOP31=982
    HINT_NOP32=983
    HINT_NOP33=984
    HINT_NOP34=985
    HINT_NOP35=986
    HINT_NOP36=987
    HINT_NOP37=988
    HINT_NOP38=989
    HINT_NOP39=990
    HINT_NOP4=991
    HINT_NOP40=992
    HINT_NOP41=993
    HINT_NOP42=994
    HINT_NOP43=995
    HINT_NOP44=996
    HINT_NOP45=997
    HINT_NOP46=998
    HINT_NOP47=999
    HINT_NOP48=1000
    HINT_NOP49=1001
    HINT_NOP5=1002
    HINT_NOP50=1003
    HINT_NOP51=1004
    HINT_NOP52=1005
    HINT_NOP53=1006
    HINT_NOP54=1007
    HINT_NOP55=1008
    HINT_NOP56=1009
    HINT_NOP57=1010
    HINT_NOP58=1011
    HINT_NOP59=1012
    HINT_NOP6=1013
    HINT_NOP60=1014
    HINT_NOP61=1015
    HINT_NOP62=1016
    HINT_NOP63=1017
    HINT_NOP7=1018
    HINT_NOP8=1019
    HINT_NOP9=1020
    HRESET=1021
    HSUBPD=1022
    HSUBPS=1023
    INCSSPD=1024
    INCSSPQ=1025
    INSERTPS=1026
    INSERTQ=1027
    INVEPT=1028
    INVVPID=1029
    KADD=1030
    KADDB=1031
    KADDD=1032
    KADDQ=1033
    KADDW=1034
    KAND=1035
    KANDB=1036
    KANDD=1037
    KANDN=1038
    KANDNB=1039
    KANDND=1040
    KANDNQ=1041
    KANDNW=1042
    KANDQ=1043
    KANDW=1044
    KMOV=1045
    KMOVB=1046
    KMOVD=1047
    KMOVQ=1048
    KMOVW=1049
    KNOT=1050
    KNOTB=1051
    KNOTD=1052
    KNOTQ=1053
    KNOTW=1054
    KOR=1055
    KORB=1056
    KORD=1057
    KORQ=1058
    KORTEST=1059
    KORTESTB=1060
    KORTESTD=1061
    KORTESTQ=1062
    KORTESTW=1063
    KORW=1064
    KSHIFTL=1065
    KSHIFTLB=1066
    KSHIFTLD=1067
    KSHIFTLQ=1068
    KSHIFTLW=1069
    KSHIFTR=1070
    KSHIFTRB=1071
    KSHIFTRD=1072
    KSHIFTRQ=1073
    KSHIFTRW=1074
    KTEST=1075
    KTESTB=1076
    KTESTD=1077
    KTESTQ=1078
    KTESTW=1079
    KUNPCK=1080
    KUNPCKBW=1081
    KUNPCKDQ=1082
    KUNPCKWD=1083
    KXNOR=1084
    KXNORB=1085
    KXNORD=1086
    KXNORQ=1087
    KXNORW=1088
    KXOR=1089
    KXORB=1090
    KXORD=1091
    KXORQ=1092
    KXORW=1093
    LDDQU=1094
    LDMXCSR=1095
    LDTILECFG=1096
    LLWPCB=1097
    LWPINS=1098
    LWPVAL=1099
    LZCNT=1100
    MASKMOVDQU=1101
    MASKMOVQ=1102
    MAXPD=1103
    MAXPS=1104
    MAXSD=1105
    MAXSS=1106
    MINPD=1107
    MINPS=1108
    MINSD=1109
    MINSS=1110
    MONTMUL=1111
    MOVAPD=1112
    MOVAPS=1113
    MOVBE=1114
    MOVDDUP=1115
    MOVDIR64B=1116
    MOVDIRI=1117
    MOVDQ2Q=1118
    MOVDQA=1119
    MOVDQU=1120
    MOVHLPS=1121
    MOVHPD=1122
    MOVHPS=1123
    MOVLHPS=1124
    MOVLPD=1125
    MOVLPS=1126
    MOVMSKPD=1127
    MOVMSKPS=1128
    MOVNTDQ=1129
    MOVNTDQA=1130
    MOVNTI=1131
    MOVNTPD=1132
    MOVNTPS=1133
    MOVNTQ=1134
    MOVNTSD=1135
    MOVNTSS=1136
    MOVQ2DQ=1137
    MOVSHDUP=1138
    MOVSLDUP=1139
    MOVSS=1140
    MOVUPD=1141
    MOVUPS=1142
    MPSADBW=1143
    MULPD=1144
    MULPS=1145
    MULSD=1146
    MULSS=1147
    MULX=1148
    ORPD=1149
    ORPS=1150
    PABSB=1151
    PABSD=1152
    PABSW=1153
    PACKUSDW=1154
    PADDQ=1155
    PALIGNR=1156
    PAVGB=1157
    PAVGW=1158
    PBLENDVB=1159
    PBLENDW=1160
    PCLMULHQHQDQ=1161
    PCLMULHQLQDQ=1162
    PCLMULLQHQDQ=1163
    PCLMULLQLQDQ=1164
    PCLMULQDQ=1165
    PCMPEQQ=1166
    PCMPESTRI=1167
    PCMPESTRM=1168
    PCMPGTQ=1169
    PCMPISTRI=1170
    PCMPISTRM=1171
    PCOMMIT=1172
    PCONFIG=1173
    PDEP=1174
    PEXT=1175
    PEXTRB=1176
    PEXTRD=1177
    PEXTRQ=1178
    PEXTRW=1179
    PF2IW=1180
    PFNACC=1181
    PFPNACC=1182
    PFRCPV=1183
    PFRSQRTV=1184
    PHADDD=1185
    PHADDSW=1186
    PHADDW=1187
    PHMINPOSUW=1188
    PHSUBD=1189
    PHSUBSW=1190
    PHSUBW=1191
    PI2FW=1192
    PINSRB=1193
    PINSRD=1194
    PINSRQ=1195
    PINSRW=1196
    PMADDUBSW=1197
    PMAXSB=1198
    PMAXSD=1199
    PMAXSW=1200
    PMAXUB=1201
    PMAXUD=1202
    PMAXUW=1203
    PMINSB=1204
    PMINSD=1205
    PMINSW=1206
    PMINUB=1207
    PMINUD=1208
    PMINUW=1209
    PMOVMSKB=1210
    PMOVSXBD=1211
    PMOVSXBQ=1212
    PMOVSXBW=1213
    PMOVSXDQ=1214
    PMOVSXWD=1215
    PMOVSXWQ=1216
    PMOVZXBD=1217
    PMOVZXBQ=1218
    PMOVZXBW=1219
    PMOVZXDQ=1220
    PMOVZXWD=1221
    PMOVZXWQ=1222
    PMULDQ=1223
    PMULHRSW=1224
    PMULHUW=1225
    PMULLD=1226
    PMULUDQ=1227
    POPCNT=1228
    PREFETCHIT0=1229
    PREFETCHIT1=1230
    PREFETCHNTA=1231
    PREFETCHT0=1232
    PREFETCHT1=1233
    PREFETCHT2=1234
    PREFETCHWT1=1235
    PSADBW=1236
    PSHUFB=1237
    PSHUFD=1238
    PSHUFHW=1239
    PSHUFLW=1240
    PSHUFW=1241
    PSIGNB=1242
    PSIGND=1243
    PSIGNW=1244
    PSLLDQ=1245
    PSRLDQ=1246
    PSUBQ=1247
    PSWAPD=1248
    PTEST=1249
    PTWRITE=1250
    PUNPCKHQDQ=1251
    PUNPCKLQDQ=1252
    PVALIDATE=1253
    RCPPS=1254
    RCPSS=1255
    RDFSBASE=1256
    RDGSBASE=1257
    RDMSRLIST=1258
    RDPID=1259
    RDPKRU=1260
    RDRAND=1261
    RDSEED=1262
    RDSSPD=1263
    RDSSPQ=1264
    RMPADJUST=1265
    RORX=1266
    ROUNDPD=1267
    ROUNDPS=1268
    ROUNDSD=1269
    ROUNDSS=1270
    RSQRTPS=1271
    RSQRTSS=1272
    RSTORSSP=1273
    SARX=1274
    SAVEPREVSSP=1275
    SENDUIPI=1276
    SERIALIZE=1277
    SETSSBSY=1278
    SHA1MSG1=1279
    SHA1MSG2=1280
    SHA1NEXTE=1281
    SHA1RNDS4=1282
    SHA256MSG1=1283
    SHA256MSG2=1284
    SHA256RNDS2=1285
    SHLX=1286
    SHRX=1287
    SHUFPD=1288
    SHUFPS=1289
    SLWPCB=1290
    SQRTPD=1291
    SQRTPS=1292
    SQRTSD=1293
    SQRTSS=1294
    STAC=1295
    STGI=1296
    STMXCSR=1297
    STTILECFG=1298
    STUI=1299
    SUBPD=1300
    SUBPS=1301
    SUBSD=1302
    SUBSS=1303
    T1MSKC=1304
    TDPBF16PS=1305
    TDPBSSD=1306
    TDPBSUD=1307
    TDPBUSD=1308
    TDPBUUD=1309
    TESTUI=1310
    TILELOADD=1311
    TILELOADDT1=1312
    TILERELEASE=1313
    TILESTORED=1314
    TILEZERO=1315
    TPAUSE=1316
    TZCNT=1317
    TZMSK=1318
    UCOMISD=1319
    UCOMISS=1320
    UIRET=1321
    UMONITOR=1322
    UMWAIT=1323
    UNPCKHPD=1324
    UNPCKHPS=1325
    UNPCKLPD=1326
    UNPCKLPS=1327
    V4DPWSSD=1328
    V4DPWSSDS=1329
    V4FMADDPS=1330
    V4FMADDSS=1331
    V4FNMADDPS=1332
    V4FNMADDSS=1333
    VADDPD=1334
    VADDPH=1335
    VADDPS=1336
    VADDSD=1337
    VADDSH=1338
    VADDSS=1339
    VADDSUBPD=1340
    VADDSUBPS=1341
    VAESDEC=1342
    VAESDECLAST=1343
    VAESENC=1344
    VAESENCLAST=1345
    VAESIMC=1346
    VAESKEYGENASSIST=1347
    VALIGND=1348
    VALIGNQ=1349
    VANDNPD=1350
    VANDNPS=1351
    VANDPD=1352
    VANDPS=1353
    VBCSTNEBF16PS=1354
    VBCSTNESH2PS=1355
    VBLENDMPD=1356
    VBLENDMPS=1357
    VBLENDPD=1358
    VBLENDPS=1359
    VBLENDVPD=1360
    VBLENDVPS=1361
    VBROADCASTF128=1362
    VBROADCASTF32X2=1363
    VBROADCASTF32X4=1364
    VBROADCASTF32X8=1365
    VBROADCASTF64X2=1366
    VBROADCASTF64X4=1367
    VBROADCASTI128=1368
    VBROADCASTI32X2=1369
    VBROADCASTI32X4=1370
    VBROADCASTI32X8=1371
    VBROADCASTI64X2=1372
    VBROADCASTI64X4=1373
    VBROADCASTSD=1374
    VBROADCASTSS=1375
    VCMPEQ_OQPD=1376
    VCMPEQ_OQPS=1377
    VCMPEQ_OQSD=1378
    VCMPEQ_OQSS=1379
    VCMPEQ_OSPD=1380
    VCMPEQ_OSPS=1381
    VCMPEQ_OSSD=1382
    VCMPEQ_OSSS=1383
    VCMPEQ_UQPD=1384
    VCMPEQ_UQPS=1385
    VCMPEQ_UQSD=1386
    VCMPEQ_UQSS=1387
    VCMPEQ_USPD=1388
    VCMPEQ_USPS=1389
    VCMPEQ_USSD=1390
    VCMPEQ_USSS=1391
    VCMPEQPD=1392
    VCMPEQPS=1393
    VCMPEQSD=1394
    VCMPEQSS=1395
    VCMPFALSE_OQPD=1396
    VCMPFALSE_OQPS=1397
    VCMPFALSE_OQSD=1398
    VCMPFALSE_OQSS=1399
    VCMPFALSE_OSPD=1400
    VCMPFALSE_OSPS=1401
    VCMPFALSE_OSSD=1402
    VCMPFALSE_OSSS=1403
    VCMPFALSEPD=1404
    VCMPFALSEPS=1405
    VCMPFALSESD=1406
    VCMPFALSESS=1407
    VCMPGE_OQPD=1408
    VCMPGE_OQPS=1409
    VCMPGE_OQSD=1410
    VCMPGE_OQSS=1411
    VCMPGE_OSPD=1412
    VCMPGE_OSPS=1413
    VCMPGE_OSSD=1414
    VCMPGE_OSSS=1415
    VCMPGEPD=1416
    VCMPGEPS=1417
    VCMPGESD=1418
    VCMPGESS=1419
    VCMPGT_OQPD=1420
    VCMPGT_OQPS=1421
    VCMPGT_OQSD=1422
    VCMPGT_OQSS=1423
    VCMPGT_OSPD=1424
    VCMPGT_OSPS=1425
    VCMPGT_OSSD=1426
    VCMPGT_OSSS=1427
    VCMPGTPD=1428
    VCMPGTPS=1429
    VCMPGTSD=1430
    VCMPGTSS=1431
    VCMPLE_OQPD=1432
    VCMPLE_OQPS=1433
    VCMPLE_OQSD=1434
    VCMPLE_OQSS=1435
    VCMPLE_OSPD=1436
    VCMPLE_OSPS=1437
    VCMPLE_OSSD=1438
    VCMPLE_OSSS=1439
    VCMPLEPD=1440
    VCMPLEPS=1441
    VCMPLESD=1442
    VCMPLESS=1443
    VCMPLT_OQPD=1444
    VCMPLT_OQPS=1445
    VCMPLT_OQSD=1446
    VCMPLT_OQSS=1447
    VCMPLT_OSPD=1448
    VCMPLT_OSPS=1449
    VCMPLT_OSSD=1450
    VCMPLT_OSSS=1451
    VCMPLTPD=1452
    VCMPLTPS=1453
    VCMPLTSD=1454
    VCMPLTSS=1455
    VCMPNEQ_OQPD=1456
    VCMPNEQ_OQPS=1457
    VCMPNEQ_OQSD=1458
    VCMPNEQ_OQSS=1459
    VCMPNEQ_OSPD=1460
    VCMPNEQ_OSPS=1461
    VCMPNEQ_OSSD=1462
    VCMPNEQ_OSSS=1463
    VCMPNEQ_UQPD=1464
    VCMPNEQ_UQPS=1465
    VCMPNEQ_UQSD=1466
    VCMPNEQ_UQSS=1467
    VCMPNEQ_USPD=1468
    VCMPNEQ_USPS=1469
    VCMPNEQ_USSD=1470
    VCMPNEQ_USSS=1471
    VCMPNEQPD=1472
    VCMPNEQPS=1473
    VCMPNEQSD=1474
    VCMPNEQSS=1475
    VCMPNGE_UQPD=1476
    VCMPNGE_UQPS=1477
    VCMPNGE_UQSD=1478
    VCMPNGE_UQSS=1479
    VCMPNGE_USPD=1480
    VCMPNGE_USPS=1481
    VCMPNGE_USSD=1482
    VCMPNGE_USSS=1483
    VCMPNGEPD=1484
    VCMPNGEPS=1485
    VCMPNGESD=1486
    VCMPNGESS=1487
    VCMPNGT_UQPD=1488
    VCMPNGT_UQPS=1489
    VCMPNGT_UQSD=1490
    VCMPNGT_UQSS=1491
    VCMPNGT_USPD=1492
    VCMPNGT_USPS=1493
    VCMPNGT_USSD=1494
    VCMPNGT_USSS=1495
    VCMPNGTPD=1496
    VCMPNGTPS=1497
    VCMPNGTSD=1498
    VCMPNGTSS=1499
    VCMPNLE_UQPD=1500
    VCMPNLE_UQPS=1501
    VCMPNLE_UQSD=1502
    VCMPNLE_UQSS=1503
    VCMPNLE_USPD=1504
    VCMPNLE_USPS=1505
    VCMPNLE_USSD=1506
    VCMPNLE_USSS=1507
    VCMPNLEPD=1508
    VCMPNLEPS=1509
    VCMPNLESD=1510
    VCMPNLESS=1511
    VCMPNLT_UQPD=1512
    VCMPNLT_UQPS=1513
    VCMPNLT_UQSD=1514
    VCMPNLT_UQSS=1515
    VCMPNLT_USPD=1516
    VCMPNLT_USPS=1517
    VCMPNLT_USSD=1518
    VCMPNLT_USSS=1519
    VCMPNLTPD=1520
    VCMPNLTPS=1521
    VCMPNLTSD=1522
    VCMPNLTSS=1523
    VCMPORD_QPD=1524
    VCMPORD_QPS=1525
    VCMPORD_QSD=1526
    VCMPORD_QSS=1527
    VCMPORD_SPD=1528
    VCMPORD_SPS=1529
    VCMPORD_SSD=1530
    VCMPORD_SSS=1531
    VCMPORDPD=1532
    VCMPORDPS=1533
    VCMPORDSD=1534
    VCMPORDSS=1535
    VCMPPD=1536
    VCMPPH=1537
    VCMPPS=1538
    VCMPSD=1539
    VCMPSH=1540
    VCMPSS=1541
    VCMPTRUE_UQPD=1542
    VCMPTRUE_UQPS=1543
    VCMPTRUE_UQSD=1544
    VCMPTRUE_UQSS=1545
    VCMPTRUE_USPD=1546
    VCMPTRUE_USPS=1547
    VCMPTRUE_USSD=1548
    VCMPTRUE_USSS=1549
    VCMPTRUEPD=1550
    VCMPTRUEPS=1551
    VCMPTRUESD=1552
    VCMPTRUESS=1553
    VCMPUNORD_QPD=1554
    VCMPUNORD_QPS=1555
    VCMPUNORD_QSD=1556
    VCMPUNORD_QSS=1557
    VCMPUNORD_SPD=1558
    VCMPUNORD_SPS=1559
    VCMPUNORD_SSD=1560
    VCMPUNORD_SSS=1561
    VCMPUNORDPD=1562
    VCMPUNORDPS=1563
    VCMPUNORDSD=1564
    VCMPUNORDSS=1565
    VCOMISD=1566
    VCOMISH=1567
    VCOMISS=1568
    VCOMPRESSPD=1569
    VCOMPRESSPS=1570
    VCVTDQ2PD=1571
    VCVTDQ2PH=1572
    VCVTDQ2PS=1573
    VCVTNE2PS2BF16=1574
    VCVTNEEBF162PS=1575
    VCVTNEEPH2PS=1576
    VCVTNEOBF162PS=1577
    VCVTNEOPH2PS=1578
    VCVTNEPS2BF16=1579
    VCVTPD2DQ=1580
    VCVTPD2PH=1581
    VCVTPD2PS=1582
    VCVTPD2QQ=1583
    VCVTPD2UDQ=1584
    VCVTPD2UQQ=1585
    VCVTPH2DQ=1586
    VCVTPH2PD=1587
    VCVTPH2PS=1588
    VCVTPH2PSX=1589
    VCVTPH2QQ=1590
    VCVTPH2UDQ=1591
    VCVTPH2UQQ=1592
    VCVTPH2UW=1593
    VCVTPH2W=1594
    VCVTPS2DQ=1595
    VCVTPS2PD=1596
    VCVTPS2PH=1597
    VCVTPS2QQ=1598
    VCVTPS2UDQ=1599
    VCVTPS2UQQ=1600
    VCVTQQ2PD=1601
    VCVTQQ2PH=1602
    VCVTQQ2PS=1603
    VCVTSD2SH=1604
    VCVTSD2SI=1605
    VCVTSD2SS=1606
    VCVTSD2USI=1607
    VCVTSH2SD=1608
    VCVTSH2SI=1609
    VCVTSH2SS=1610
    VCVTSH2USI=1611
    VCVTSI2SD=1612
    VCVTSI2SH=1613
    VCVTSI2SS=1614
    VCVTSS2SD=1615
    VCVTSS2SH=1616
    VCVTSS2SI=1617
    VCVTSS2USI=1618
    VCVTTPD2DQ=1619
    VCVTTPD2QQ=1620
    VCVTTPD2UDQ=1621
    VCVTTPD2UQQ=1622
    VCVTTPH2DQ=1623
    VCVTTPH2QQ=1624
    VCVTTPH2UDQ=1625
    VCVTTPH2UQQ=1626
    VCVTTPH2UW=1627
    VCVTTPH2W=1628
    VCVTTPS2DQ=1629
    VCVTTPS2QQ=1630
    VCVTTPS2UDQ=1631
    VCVTTPS2UQQ=1632
    VCVTTSD2SI=1633
    VCVTTSD2USI=1634
    VCVTTSH2SI=1635
    VCVTTSH2USI=1636
    VCVTTSS2SI=1637
    VCVTTSS2USI=1638
    VCVTUDQ2PD=1639
    VCVTUDQ2PH=1640
    VCVTUDQ2PS=1641
    VCVTUQQ2PD=1642
    VCVTUQQ2PH=1643
    VCVTUQQ2PS=1644
    VCVTUSI2SD=1645
    VCVTUSI2SH=1646
    VCVTUSI2SS=1647
    VCVTUW2PH=1648
    VCVTW2PH=1649
    VDBPSADBW=1650
    VDIVPD=1651
    VDIVPH=1652
    VDIVPS=1653
    VDIVSD=1654
    VDIVSH=1655
    VDIVSS=1656
    VDPBF16PS=1657
    VDPPD=1658
    VDPPS=1659
    VENDSCALEPH=1660
    VENDSCALESH=1661
    VEXP2PD=1662
    VEXP2PS=1663
    VEXPANDPD=1664
    VEXPANDPS=1665
    VEXTRACTF128=1666
    VEXTRACTF32X4=1667
    VEXTRACTF32X8=1668
    VEXTRACTF64X2=1669
    VEXTRACTF64X4=1670
    VEXTRACTI128=1671
    VEXTRACTI32X4=1672
    VEXTRACTI32X8=1673
    VEXTRACTI64X2=1674
    VEXTRACTI64X4=1675
    VEXTRACTPS=1676
    VFCMADDCPH=1677
    VFCMADDCSH=1678
    VFCMULCPCH=1679
    VFCMULCSH=1680
    VFIXUPIMMPD=1681
    VFIXUPIMMPS=1682
    VFIXUPIMMSD=1683
    VFIXUPIMMSS=1684
    VFMADD123PD=1685
    VFMADD123PS=1686
    VFMADD123SD=1687
    VFMADD123SS=1688
    VFMADD132PD=1689
    VFMADD132PH=1690
    VFMADD132PS=1691
    VFMADD132SD=1692
    VFMADD132SS=1693
    VFMADD213PD=1694
    VFMADD213PH=1695
    VFMADD213PS=1696
    VFMADD213SD=1697
    VFMADD213SS=1698
    VFMADD231PD=1699
    VFMADD231PH=1700
    VFMADD231PS=1701
    VFMADD231SD=1702
    VFMADD231SS=1703
    VFMADD312PD=1704
    VFMADD312PS=1705
    VFMADD312SD=1706
    VFMADD312SS=1707
    VFMADD321PD=1708
    VFMADD321PS=1709
    VFMADD321SD=1710
    VFMADD321SS=1711
    VFMADDCPH=1712
    VFMADDCSH=1713
    VFMADDPD=1714
    VFMADDPS=1715
    VFMADDSD=1716
    VFMADDSS=1717
    VFMADDSUB123PD=1718
    VFMADDSUB123PS=1719
    VFMADDSUB132PD=1720
    VFMADDSUB132PH=1721
    VFMADDSUB132PS=1722
    VFMADDSUB213PD=1723
    VFMADDSUB213PH=1724
    VFMADDSUB213PS=1725
    VFMADDSUB231PD=1726
    VFMADDSUB231PH=1727
    VFMADDSUB231PS=1728
    VFMADDSUB312PD=1729
    VFMADDSUB312PS=1730
    VFMADDSUB321PD=1731
    VFMADDSUB321PS=1732
    VFMADDSUBPD=1733
    VFMADDSUBPS=1734
    VFMSUB123PD=1735
    VFMSUB123PS=1736
    VFMSUB123SD=1737
    VFMSUB123SS=1738
    VFMSUB132PD=1739
    VFMSUB132PH=1740
    VFMSUB132PS=1741
    VFMSUB132SD=1742
    VFMSUB132SS=1743
    VFMSUB213PD=1744
    VFMSUB213PH=1745
    VFMSUB213PS=1746
    VFMSUB213SD=1747
    VFMSUB213SS=1748
    VFMSUB231PD=1749
    VFMSUB231PH=1750
    VFMSUB231PS=1751
    VFMSUB231SD=1752
    VFMSUB231SS=1753
    VFMSUB312PD=1754
    VFMSUB312PS=1755
    VFMSUB312SD=1756
    VFMSUB312SS=1757
    VFMSUB321PD=1758
    VFMSUB321PS=1759
    VFMSUB321SD=1760
    VFMSUB321SS=1761
    VFMSUBADD123PD=1762
    VFMSUBADD123PS=1763
    VFMSUBADD132PD=1764
    VFMSUBADD132PH=1765
    VFMSUBADD132PS=1766
    VFMSUBADD213PD=1767
    VFMSUBADD213PH=1768
    VFMSUBADD213PS=1769
    VFMSUBADD231PD=1770
    VFMSUBADD231PH=1771
    VFMSUBADD231PS=1772
    VFMSUBADD312PD=1773
    VFMSUBADD312PS=1774
    VFMSUBADD321PD=1775
    VFMSUBADD321PS=1776
    VFMSUBADDPD=1777
    VFMSUBADDPS=1778
    VFMSUBPD=1779
    VFMSUBPS=1780
    VFMSUBSD=1781
    VFMSUBSS=1782
    VFMULCPCH=1783
    VFMULCSH=1784
    VFNMADD123PD=1785
    VFNMADD123PS=1786
    VFNMADD123SD=1787
    VFNMADD123SS=1788
    VFNMADD132PD=1789
    VFNMADD132PS=1790
    VFNMADD132SD=1791
    VFNMADD132SS=1792
    VFNMADD213PD=1793
    VFNMADD213PS=1794
    VFNMADD213SD=1795
    VFNMADD213SS=1796
    VFNMADD231PD=1797
    VFNMADD231PS=1798
    VFNMADD231SD=1799
    VFNMADD231SS=1800
    VFNMADD312PD=1801
    VFNMADD312PS=1802
    VFNMADD312SD=1803
    VFNMADD312SS=1804
    VFNMADD321PD=1805
    VFNMADD321PS=1806
    VFNMADD321SD=1807
    VFNMADD321SS=1808
    VFNMADDPD=1809
    VFNMADDPS=1810
    VFNMADDSD=1811
    VFNMADDSS=1812
    VFNMSUB123PD=1813
    VFNMSUB123PS=1814
    VFNMSUB123SD=1815
    VFNMSUB123SS=1816
    VFNMSUB132PD=1817
    VFNMSUB132PS=1818
    VFNMSUB132SD=1819
    VFNMSUB132SS=1820
    VFNMSUB213PD=1821
    VFNMSUB213PS=1822
    VFNMSUB213SD=1823
    VFNMSUB213SS=1824
    VFNMSUB231PD=1825
    VFNMSUB231PS=1826
    VFNMSUB231SD=1827
    VFNMSUB231SS=1828
    VFNMSUB312PD=1829
    VFNMSUB312PS=1830
    VFNMSUB312SD=1831
    VFNMSUB312SS=1832
    VFNMSUB321PD=1833
    VFNMSUB321PS=1834
    VFNMSUB321SD=1835
    VFNMSUB321SS=1836
    VFNMSUBPD=1837
    VFNMSUBPS=1838
    VFNMSUBSD=1839
    VFNMSUBSS=1840
    VFPCLASSPD=1841
    VFPCLASSPH=1842
    VFPCLASSPS=1843
    VFPCLASSSD=1844
    VFPCLASSSH=1845
    VFPCLASSSS=1846
    VFRCZPD=1847
    VFRCZPS=1848
    VFRCZSD=1849
    VFRCZSS=1850
    VGATHERDPD=1851
    VGATHERDPS=1852
    VGATHERPF0DPD=1853
    VGATHERPF0DPS=1854
    VGATHERPF0QPD=1855
    VGATHERPF0QPS=1856
    VGATHERPF1DPD=1857
    VGATHERPF1DPS=1858
    VGATHERPF1QPD=1859
    VGATHERPF1QPS=1860
    VGATHERQPD=1861
    VGATHERQPS=1862
    VGETEXPPD=1863
    VGETEXPPH=1864
    VGETEXPPS=1865
    VGETEXPSD=1866
    VGETEXPSH=1867
    VGETEXPSS=1868
    VGETMANTPD=1869
    VGETMANTPH=1870
    VGETMANTPS=1871
    VGETMANTSD=1872
    VGETMANTSH=1873
    VGETMANTSS=1874
    VGETMAXPH=1875
    VGETMAXSH=1876
    VGETMINPH=1877
    VGETMINSH=1878
    VGF2P8AFFINEINVQB=1879
    VGF2P8AFFINEQB=1880
    VGF2P8MULB=1881
    VHADDPD=1882
    VHADDPS=1883
    VHSUBPD=1884
    VHSUBPS=1885
    VINSERTF128=1886
    VINSERTF32X4=1887
    VINSERTF32X8=1888
    VINSERTF64X2=1889
    VINSERTF64X4=1890
    VINSERTI128=1891
    VINSERTI32X4=1892
    VINSERTI32X8=1893
    VINSERTI64X2=1894
    VINSERTI64X4=1895
    VINSERTPS=1896
    VLDDQU=1897
    VLDMXCSR=1898
    VLDQQU=1899
    VMASKMOVDQU=1900
    VMASKMOVPD=1901
    VMASKMOVPS=1902
    VMAXPD=1903
    VMAXPS=1904
    VMAXSD=1905
    VMAXSS=1906
    VMCALL=1907
    VMCLEAR=1908
    VMFUNC=1909
    VMGEXIT=1910
    VMINPD=1911
    VMINPS=1912
    VMINSD=1913
    VMINSS=1914
    VMLAUNCH=1915
    VMLOAD=1916
    VMMCALL=1917
    VMOVAPD=1918
    VMOVAPS=1919
    VMOVD=1920
    VMOVDDUP=1921
    VMOVDQA=1922
    VMOVDQA32=1923
    VMOVDQA64=1924
    VMOVDQU=1925
    VMOVDQU16=1926
    VMOVDQU32=1927
    VMOVDQU64=1928
    VMOVDQU8=1929
    VMOVHLPS=1930
    VMOVHPD=1931
    VMOVHPS=1932
    VMOVLHPS=1933
    VMOVLPD=1934
    VMOVLPS=1935
    VMOVMSKPD=1936
    VMOVMSKPS=1937
    VMOVNTDQ=1938
    VMOVNTDQA=1939
    VMOVNTPD=1940
    VMOVNTPS=1941
    VMOVNTQQ=1942
    VMOVQ=1943
    VMOVQQA=1944
    VMOVQQU=1945
    VMOVSD=1946
    VMOVSH=1947
    VMOVSHDUP=1948
    VMOVSLDUP=1949
    VMOVSS=1950
    VMOVUPD=1951
    VMOVUPS=1952
    VMOVW=1953
    VMPSADBW=1954
    VMPTRLD=1955
    VMPTRST=1956
    VMREAD=1957
    VMRESUME=1958
    VMRUN=1959
    VMSAVE=1960
    VMULPD=1961
    VMULPH=1962
    VMULPS=1963
    VMULSD=1964
    VMULSH=1965
    VMULSS=1966
    VMWRITE=1967
    VMXOFF=1968
    VMXON=1969
    VORPD=1970
    VORPS=1971
    VP2INTERSECTD=1972
    VPABSB=1973
    VPABSD=1974
    VPABSQ=1975
    VPABSW=1976
    VPACKSSDW=1977
    VPACKSSWB=1978
    VPACKUSDW=1979
    VPACKUSWB=1980
    VPADDB=1981
    VPADDD=1982
    VPADDQ=1983
    VPADDSB=1984
    VPADDSW=1985
    VPADDUSB=1986
    VPADDUSW=1987
    VPADDW=1988
    VPALIGNR=1989
    VPAND=1990
    VPANDD=1991
    VPANDN=1992
    VPANDND=1993
    VPANDNQ=1994
    VPANDQ=1995
    VPAVGB=1996
    VPAVGW=1997
    VPBLENDD=1998
    VPBLENDMB=1999
    VPBLENDMD=2000
    VPBLENDMQ=2001
    VPBLENDMW=2002
    VPBLENDVB=2003
    VPBLENDW=2004
    VPBROADCASTB=2005
    VPBROADCASTD=2006
    VPBROADCASTMB2Q=2007
    VPBROADCASTMW2D=2008
    VPBROADCASTQ=2009
    VPBROADCASTW=2010
    VPCLMULHQHQDQ=2011
    VPCLMULHQLQDQ=2012
    VPCLMULLQHQDQ=2013
    VPCLMULLQLQDQ=2014
    VPCLMULQDQ=2015
    VPCMOV=2016
    VPCMPB=2017
    VPCMPD=2018
    VPCMPEQB=2019
    VPCMPEQD=2020
    VPCMPEQQ=2021
    VPCMPEQUB=2022
    VPCMPEQUD=2023
    VPCMPEQUQ=2024
    VPCMPEQUW=2025
    VPCMPEQW=2026
    VPCMPESTRI=2027
    VPCMPESTRM=2028
    VPCMPGEB=2029
    VPCMPGED=2030
    VPCMPGEQ=2031
    VPCMPGEUB=2032
    VPCMPGEUD=2033
    VPCMPGEUQ=2034
    VPCMPGEUW=2035
    VPCMPGEW=2036
    VPCMPGTB=2037
    VPCMPGTD=2038
    VPCMPGTQ=2039
    VPCMPGTUB=2040
    VPCMPGTUD=2041
    VPCMPGTUQ=2042
    VPCMPGTUW=2043
    VPCMPGTW=2044
    VPCMPISTRI=2045
    VPCMPISTRM=2046
    VPCMPLEB=2047
    VPCMPLED=2048
    VPCMPLEQ=2049
    VPCMPLEUB=2050
    VPCMPLEUD=2051
    VPCMPLEUQ=2052
    VPCMPLEUW=2053
    VPCMPLEW=2054
    VPCMPLTB=2055
    VPCMPLTD=2056
    VPCMPLTQ=2057
    VPCMPLTUB=2058
    VPCMPLTUD=2059
    VPCMPLTUQ=2060
    VPCMPLTUW=2061
    VPCMPLTW=2062
    VPCMPNEQB=2063
    VPCMPNEQD=2064
    VPCMPNEQQ=2065
    VPCMPNEQUB=2066
    VPCMPNEQUD=2067
    VPCMPNEQUQ=2068
    VPCMPNEQUW=2069
    VPCMPNEQW=2070
    VPCMPNGTB=2071
    VPCMPNGTD=2072
    VPCMPNGTQ=2073
    VPCMPNGTUB=2074
    VPCMPNGTUD=2075
    VPCMPNGTUQ=2076
    VPCMPNGTUW=2077
    VPCMPNGTW=2078
    VPCMPNLEB=2079
    VPCMPNLED=2080
    VPCMPNLEQ=2081
    VPCMPNLEUB=2082
    VPCMPNLEUD=2083
    VPCMPNLEUQ=2084
    VPCMPNLEUW=2085
    VPCMPNLEW=2086
    VPCMPNLTB=2087
    VPCMPNLTD=2088
    VPCMPNLTQ=2089
    VPCMPNLTUB=2090
    VPCMPNLTUD=2091
    VPCMPNLTUQ=2092
    VPCMPNLTUW=2093
    VPCMPNLTW=2094
    VPCMPQ=2095
    VPCMPUB=2096
    VPCMPUD=2097
    VPCMPUQ=2098
    VPCMPUW=2099
    VPCMPW=2100
    VPCOMB=2101
    VPCOMD=2102
    VPCOMPRESSB=2103
    VPCOMPRESSD=2104
    VPCOMPRESSQ=2105
    VPCOMPRESSW=2106
    VPCOMQ=2107
    VPCOMUB=2108
    VPCOMUD=2109
    VPCOMUQ=2110
    VPCOMUW=2111
    VPCOMW=2112
    VPCONFLICTD=2113
    VPCONFLICTQ=2114
    VPDPBSSD=2115
    VPDPBSSDS=2116
    VPDPBSUD=2117
    VPDPBSUDS=2118
    VPDPBUSD=2119
    VPDPBUSDS=2120
    VPDPBUUD=2121
    VPDPBUUDS=2122
    VPDPWSSD=2123
    VPDPWSSDS=2124
    VPERM2F128=2125
    VPERM2I128=2126
    VPERMB=2127
    VPERMD=2128
    VPERMI2B=2129
    VPERMI2D=2130
    VPERMI2PD=2131
    VPERMI2PS=2132
    VPERMI2Q=2133
    VPERMI2W=2134
    VPERMILPD=2135
    VPERMILPS=2136
    VPERMPD=2137
    VPERMPS=2138
    VPERMQ=2139
    VPERMT2B=2140
    VPERMT2D=2141
    VPERMT2PD=2142
    VPERMT2PS=2143
    VPERMT2Q=2144
    VPERMT2W=2145
    VPERMW=2146
    VPEXPANDB=2147
    VPEXPANDD=2148
    VPEXPANDQ=2149
    VPEXPANDW=2150
    VPEXTRB=2151
    VPEXTRD=2152
    VPEXTRQ=2153
    VPEXTRW=2154
    VPGATHERDD=2155
    VPGATHERDQ=2156
    VPGATHERQD=2157
    VPGATHERQQ=2158
    VPHADDBD=2159
    VPHADDBQ=2160
    VPHADDBW=2161
    VPHADDD=2162
    VPHADDDQ=2163
    VPHADDSW=2164
    VPHADDUBD=2165
    VPHADDUBQ=2166
    VPHADDUBW=2167
    VPHADDUDQ=2168
    VPHADDUWD=2169
    VPHADDUWQ=2170
    VPHADDW=2171
    VPHADDWD=2172
    VPHADDWQ=2173
    VPHMINPOSUW=2174
    VPHSUBBW=2175
    VPHSUBD=2176
    VPHSUBDQ=2177
    VPHSUBSW=2178
    VPHSUBW=2179
    VPHSUBWD=2180
    VPINSRB=2181
    VPINSRD=2182
    VPINSRQ=2183
    VPINSRW=2184
    VPLZCNTD=2185
    VPLZCNTQ=2186
    VPMACSDD=2187
    VPMACSDQH=2188
    VPMACSDQL=2189
    VPMACSSDD=2190
    VPMACSSDQH=2191
    VPMACSSDQL=2192
    VPMACSSWD=2193
    VPMACSSWW=2194
    VPMACSWD=2195
    VPMACSWW=2196
    VPMADCSSWD=2197
    VPMADCSWD=2198
    VPMADD132PH=2199
    VPMADD132SH=2200
    VPMADD213PH=2201
    VPMADD213SH=2202
    VPMADD231PH=2203
    VPMADD231SH=2204
    VPMADD52HUQ=2205
    VPMADD52LUQ=2206
    VPMADDUBSW=2207
    VPMADDWD=2208
    VPMASKMOVD=2209
    VPMASKMOVQ=2210
    VPMAXSB=2211
    VPMAXSD=2212
    VPMAXSQ=2213
    VPMAXSW=2214
    VPMAXUB=2215
    VPMAXUD=2216
    VPMAXUQ=2217
    VPMAXUW=2218
    VPMINSB=2219
    VPMINSD=2220
    VPMINSQ=2221
    VPMINSW=2222
    VPMINUB=2223
    VPMINUD=2224
    VPMINUQ=2225
    VPMINUW=2226
    VPMOVB2M=2227
    VPMOVD2M=2228
    VPMOVDB=2229
    VPMOVDW=2230
    VPMOVM2B=2231
    VPMOVM2D=2232
    VPMOVM2Q=2233
    VPMOVM2W=2234
    VPMOVMSKB=2235
    VPMOVQ2M=2236
    VPMOVQB=2237
    VPMOVQD=2238
    VPMOVQW=2239
    VPMOVSDB=2240
    VPMOVSDW=2241
    VPMOVSQB=2242
    VPMOVSQD=2243
    VPMOVSQW=2244
    VPMOVSWB=2245
    VPMOVSXBD=2246
    VPMOVSXBQ=2247
    VPMOVSXBW=2248
    VPMOVSXDQ=2249
    VPMOVSXWD=2250
    VPMOVSXWQ=2251
    VPMOVUSDB=2252
    VPMOVUSDW=2253
    VPMOVUSQB=2254
    VPMOVUSQD=2255
    VPMOVUSQW=2256
    VPMOVUSWB=2257
    VPMOVW2M=2258
    VPMOVWB=2259
    VPMOVZXBD=2260
    VPMOVZXBQ=2261
    VPMOVZXBW=2262
    VPMOVZXDQ=2263
    VPMOVZXWD=2264
    VPMOVZXWQ=2265
    VPMSUB132PH=2266
    VPMSUB132SH=2267
    VPMSUB213PH=2268
    VPMSUB213SH=2269
    VPMSUB231PH=2270
    VPMSUB231SH=2271
    VPMULDQ=2272
    VPMULHRSW=2273
    VPMULHUW=2274
    VPMULHW=2275
    VPMULLD=2276
    VPMULLQ=2277
    VPMULLW=2278
    VPMULTISHIFTQB=2279
    VPMULUDQ=2280
    VPNMADD132SH=2281
    VPNMADD213SH=2282
    VPNMADD231SH=2283
    VPNMSUB132SH=2284
    VPNMSUB213SH=2285
    VPNMSUB231SH=2286
    VPOPCNTB=2287
    VPOPCNTD=2288
    VPOPCNTQ=2289
    VPOPCNTW=2290
    VPOR=2291
    VPORD=2292
    VPORQ=2293
    VPPERM=2294
    VPROLD=2295
    VPROLQ=2296
    VPROLVD=2297
    VPROLVQ=2298
    VPRORD=2299
    VPRORQ=2300
    VPRORVD=2301
    VPRORVQ=2302
    VPROTB=2303
    VPROTD=2304
    VPROTQ=2305
    VPROTW=2306
    VPSADBW=2307
    VPSCATTERDD=2308
    VPSCATTERDQ=2309
    VPSCATTERQD=2310
    VPSCATTERQQ=2311
    VPSHAB=2312
    VPSHAD=2313
    VPSHAQ=2314
    VPSHAW=2315
    VPSHLB=2316
    VPSHLD=2317
    VPSHLDD=2318
    VPSHLDQ=2319
    VPSHLDVD=2320
    VPSHLDVQ=2321
    VPSHLDVW=2322
    VPSHLDW=2323
    VPSHLQ=2324
    VPSHLW=2325
    VPSHRDD=2326
    VPSHRDQ=2327
    VPSHRDVD=2328
    VPSHRDVQ=2329
    VPSHRDVW=2330
    VPSHRDW=2331
    VPSHUFB=2332
    VPSHUFBITQMB=2333
    VPSHUFD=2334
    VPSHUFHW=2335
    VPSHUFLW=2336
    VPSIGNB=2337
    VPSIGND=2338
    VPSIGNW=2339
    VPSLLD=2340
    VPSLLDQ=2341
    VPSLLQ=2342
    VPSLLVD=2343
    VPSLLVQ=2344
    VPSLLVW=2345
    VPSLLW=2346
    VPSRAD=2347
    VPSRAQ=2348
    VPSRAVD=2349
    VPSRAVQ=2350
    VPSRAVW=2351
    VPSRAW=2352
    VPSRLD=2353
    VPSRLDQ=2354
    VPSRLQ=2355
    VPSRLVD=2356
    VPSRLVQ=2357
    VPSRLVW=2358
    VPSRLW=2359
    VPSUBB=2360
    VPSUBD=2361
    VPSUBQ=2362
    VPSUBSB=2363
    VPSUBSW=2364
    VPSUBUSB=2365
    VPSUBUSW=2366
    VPSUBW=2367
    VPTERNLOGD=2368
    VPTERNLOGQ=2369
    VPTEST=2370
    VPTESTMB=2371
    VPTESTMD=2372
    VPTESTMQ=2373
    VPTESTMW=2374
    VPTESTNMB=2375
    VPTESTNMD=2376
    VPTESTNMQ=2377
    VPTESTNMW=2378
    VPUNPCKHBW=2379
    VPUNPCKHDQ=2380
    VPUNPCKHQDQ=2381
    VPUNPCKHWD=2382
    VPUNPCKLBW=2383
    VPUNPCKLDQ=2384
    VPUNPCKLQDQ=2385
    VPUNPCKLWD=2386
    VPXOR=2387
    VPXORD=2388
    VPXORQ=2389
    VRANGEPD=2390
    VRANGEPS=2391
    VRANGESD=2392
    VRANGESS=2393
    VRCP14PD=2394
    VRCP14PS=2395
    VRCP14SD=2396
    VRCP14SS=2397
    VRCP28PD=2398
    VRCP28PS=2399
    VRCP28SD=2400
    VRCP28SS=2401
    VRCPPH=2402
    VRCPPS=2403
    VRCPSH=2404
    VRCPSS=2405
    VREDUCEPD=2406
    VREDUCEPH=2407
    VREDUCEPS=2408
    VREDUCESD=2409
    VREDUCESH=2410
    VREDUCESS=2411
    VRNDSCALEPD=2412
    VRNDSCALEPS=2413
    VRNDSCALESD=2414
    VRNDSCALESS=2415
    VROUNDPD=2416
    VROUNDPS=2417
    VROUNDSD=2418
    VROUNDSS=2419
    VRSQRT14PD=2420
    VRSQRT14PS=2421
    VRSQRT14SD=2422
    VRSQRT14SS=2423
    VRSQRT28PD=2424
    VRSQRT28PS=2425
    VRSQRT28SD=2426
    VRSQRT28SS=2427
    VRSQRTPH=2428
    VRSQRTPS=2429
    VRSQRTSH=2430
    VRSQRTSS=2431
    VSCALEFPD=2432
    VSCALEFPH=2433
    VSCALEFPS=2434
    VSCALEFSD=2435
    VSCALEFSH=2436
    VSCALEFSS=2437
    VSCATTERDPD=2438
    VSCATTERDPS=2439
    VSCATTERPF0DPD=2440
    VSCATTERPF0DPS=2441
    VSCATTERPF0QPD=2442
    VSCATTERPF0QPS=2443
    VSCATTERPF1DPD=2444
    VSCATTERPF1DPS=2445
    VSCATTERPF1QPD=2446
    VSCATTERPF1QPS=2447
    VSCATTERQPD=2448
    VSCATTERQPS=2449
    VSHUFF32X4=2450
    VSHUFF64X2=2451
    VSHUFI32X4=2452
    VSHUFI64X2=2453
    VSHUFPD=2454
    VSHUFPS=2455
    VSQRTPD=2456
    VSQRTPH=2457
    VSQRTPS=2458
    VSQRTSD=2459
    VSQRTSH=2460
    VSQRTSS=2461
    VSTMXCSR=2462
    VSUBPD=2463
    VSUBPH=2464
    VSUBPS=2465
    VSUBSD=2466
    VSUBSH=2467
    VSUBSS=2468
    VTESTPD=2469
    VTESTPS=2470
    VUCOMISD=2471
    VUCOMISH=2472
    VUCOMISS=2473
    VUNPCKHPD=2474
    VUNPCKHPS=2475
    VUNPCKLPD=2476
    VUNPCKLPS=2477
    VXORPD=2478
    VXORPS=2479
    VZEROALL=2480
    VZEROUPPER=2481
    WBNOINVD=2482
    WRFSBASE=2483
    WRGSBASE=2484
    WRMSRLIST=2485
    WRMSRNS=2486
    WRPKRU=2487
    WRSSD=2488
    WRSSQ=2489
    WRUSSD=2490
    WRUSSQ=2491
    XABORT=2492
    XBEGIN=2493
    XCRYPTCBC=2494
    XCRYPTCFB=2495
    XCRYPTCTR=2496
    XCRYPTECB=2497
    XCRYPTOFB=2498
    XEND=2499
    XGETBV=2500
    XORPD=2501
    XORPS=2502
    XRESLDTRK=2503
    XRSTOR=2504
    XRSTOR64=2505
    XRSTORS=2506
    XRSTORS64=2507
    XSAVE=2508
    XSAVE64=2509
    XSAVEC=2510
    XSAVEC64=2511
    XSAVEOPT=2512
    XSAVEOPT64=2513
    XSAVES=2514
    XSAVES64=2515
    XSETBV=2516
    XSHA1=2517
    XSHA256=2518
    XSTORE=2519
    XSUSLDTRK=2520
    XTEST=2521
    BITS=2522
    USE16=2523
    USE32=2524
    DEFAULT=2525
    REL=2526
    ABS=2527
    BND=2528
    NOBND=2529
    SECTIONS=2530
    SECTION=2531
    SEGMENTS=2532
    SEGMENT=2533
    ABSOLUTE=2534
    EXTERN=2535
    REQUIRED=2536
    GLOBAL=2537
    COMMON=2538
    NEAR=2539
    FAR=2540
    STATIC=2541
    CPU=2542
    FLOAT_NAME=2543
    DAZ=2544
    NODAZ=2545
    UP=2546
    DOWN=2547
    ZERO=2548
    WARNING=2549
    ORG=2550
    ALIGN=2551
    VSTART=2552
    START=2553
    PROGBITS=2554
    NOBITS=2555
    VFOLLOWS=2556
    FOLLOWS=2557
    MAP=2558
    ALL=2559
    BRIEF=2560
    SYMBOLS=2561
    PRIVATE=2562
    PUBLIC=2563
    STACK=2564
    CLASS_=2565
    OVERLAY=2566
    FLAT=2567
    GROUP=2568
    UPPERCASE=2569
    IMPORT=2570
    EXPORT=2571
    RESIDENT=2572
    NODATA=2573
    PARM=2574
    CODE=2575
    TEXT=2576
    RDATA=2577
    DATA=2578
    BSS=2579
    INFO=2580
    COMDAT=2581
    SAFESEH=2582
    MIXED=2583
    ZEROFILL=2584
    NO_DEAD_STRIP=2585
    LIVE_SUPPORT=2586
    STRIP_STATIC_SYMS=2587
    DEBUG=2588
    OSABI=2589
    NOTE=2590
    PREINIT_ARRAY=2591
    INIT_ARRAY=2592
    FINI_ARRAY=2593
    TLS=2594
    POINTER=2595
    NOALLOC=2596
    ALLOC=2597
    NOEXEC=2598
    EXEC=2599
    NOWRITE=2600
    WRITE=2601
    WRT=2602
    FUNCTION=2603
    OBJECT=2604
    WEAK=2605
    STRONG=2606
    INTERNAL=2607
    HIDDEN_=2608
    PROTECTED=2609
    STRICT=2610
    TIMES=2611
    FLOAT_NUMBER=2612
    DECIMAL_INTEGER=2613
    SIGN=2614
    OCT_INTEGER=2615
    HEX_INTEGER=2616
    BIN_INTEGER=2617
    STRING=2618
    STRING1=2619
    STRING2=2620
    WARNING_NAME=2621
    NAME=2622
    PREPROCESSOR_DIRECTIVES=2623
    MULTILINE_MACRO=2624
    COMMENT=2625
    EOL=2626
    WHITESPACE=2627

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.13.1")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class ProgramContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(nasm_x86_64_Parser.EOF, 0)

        def line(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.LineContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.LineContext,i)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_program

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProgram" ):
                listener.enterProgram(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProgram" ):
                listener.exitProgram(self)




    def program(self):

        localctx = nasm_x86_64_Parser.ProgramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_program)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 213
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2147745790) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -1) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & -1) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & -1) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & -1) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & 281474976710655) != 0) or ((((_la - 811)) & ~0x3f) == 0 and ((1 << (_la - 811)) & -1) != 0) or ((((_la - 875)) & ~0x3f) == 0 and ((1 << (_la - 875)) & -1) != 0) or ((((_la - 939)) & ~0x3f) == 0 and ((1 << (_la - 939)) & -1) != 0) or ((((_la - 1003)) & ~0x3f) == 0 and ((1 << (_la - 1003)) & -1) != 0) or ((((_la - 1067)) & ~0x3f) == 0 and ((1 << (_la - 1067)) & -1) != 0) or ((((_la - 1131)) & ~0x3f) == 0 and ((1 << (_la - 1131)) & -1) != 0) or ((((_la - 1195)) & ~0x3f) == 0 and ((1 << (_la - 1195)) & -1) != 0) or ((((_la - 1259)) & ~0x3f) == 0 and ((1 << (_la - 1259)) & -1) != 0) or ((((_la - 1323)) & ~0x3f) == 0 and ((1 << (_la - 1323)) & -1) != 0) or ((((_la - 1387)) & ~0x3f) == 0 and ((1 << (_la - 1387)) & -1) != 0) or ((((_la - 1451)) & ~0x3f) == 0 and ((1 << (_la - 1451)) & -1) != 0) or ((((_la - 1515)) & ~0x3f) == 0 and ((1 << (_la - 1515)) & -1) != 0) or ((((_la - 1579)) & ~0x3f) == 0 and ((1 << (_la - 1579)) & -1) != 0) or ((((_la - 1643)) & ~0x3f) == 0 and ((1 << (_la - 1643)) & -1) != 0) or ((((_la - 1707)) & ~0x3f) == 0 and ((1 << (_la - 1707)) & -1) != 0) or ((((_la - 1771)) & ~0x3f) == 0 and ((1 << (_la - 1771)) & -1) != 0) or ((((_la - 1835)) & ~0x3f) == 0 and ((1 << (_la - 1835)) & -1) != 0) or ((((_la - 1899)) & ~0x3f) == 0 and ((1 << (_la - 1899)) & -1) != 0) or ((((_la - 1963)) & ~0x3f) == 0 and ((1 << (_la - 1963)) & -1) != 0) or ((((_la - 2027)) & ~0x3f) == 0 and ((1 << (_la - 2027)) & -1) != 0) or ((((_la - 2091)) & ~0x3f) == 0 and ((1 << (_la - 2091)) & -1) != 0) or ((((_la - 2155)) & ~0x3f) == 0 and ((1 << (_la - 2155)) & -1) != 0) or ((((_la - 2219)) & ~0x3f) == 0 and ((1 << (_la - 2219)) & -1) != 0) or ((((_la - 2283)) & ~0x3f) == 0 and ((1 << (_la - 2283)) & -1) != 0) or ((((_la - 2347)) & ~0x3f) == 0 and ((1 << (_la - 2347)) & -1) != 0) or ((((_la - 2411)) & ~0x3f) == 0 and ((1 << (_la - 2411)) & -1) != 0) or ((((_la - 2475)) & ~0x3f) == 0 and ((1 << (_la - 2475)) & -213920982300098561) != 0) or ((((_la - 2541)) & ~0x3f) == 0 and ((1 << (_la - 2541)) & 283676013232647) != 0) or ((((_la - 2611)) & ~0x3f) == 0 and ((1 << (_la - 2611)) & 34817) != 0):
                self.state = 210
                self.line()
                self.state = 215
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 216
            self.match(nasm_x86_64_Parser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LineContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOL(self):
            return self.getToken(nasm_x86_64_Parser.EOL, 0)

        def label(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.LabelContext,0)


        def directive(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.DirectiveContext,0)


        def pseudoinstruction(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.PseudoinstructionContext,0)


        def instruction(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.InstructionContext,0)


        def times_prefix(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Times_prefixContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_line

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLine" ):
                listener.enterLine(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLine" ):
                listener.exitLine(self)




    def line(self):

        localctx = nasm_x86_64_Parser.LineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_line)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 219
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.state = 218
                self.label()


            self.state = 229
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [31, 2522, 2523, 2524, 2525, 2531, 2533, 2534, 2535, 2536, 2537, 2538, 2541, 2542, 2543, 2550, 2568, 2569, 2570, 2571, 2582, 2589]:
                self.state = 221
                self.directive()
                pass
            elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, 2506, 2507, 2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521, 2611, 2622]:
                self.state = 223
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2611:
                    self.state = 222
                    self.times_prefix()


                self.state = 227
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
                if la_ == 1:
                    self.state = 225
                    self.pseudoinstruction()
                    pass

                elif la_ == 2:
                    self.state = 226
                    self.instruction()
                    pass


                pass
            elif token in [2626]:
                pass
            else:
                pass
            self.state = 231
            self.match(nasm_x86_64_Parser.EOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabelContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_label

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLabel" ):
                listener.enterLabel(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLabel" ):
                listener.exitLabel(self)




    def label(self):

        localctx = nasm_x86_64_Parser.LabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_label)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 233
            self.name()
            self.state = 234
            self.match(nasm_x86_64_Parser.COLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def bits(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.BitsContext,0)


        def decimal_integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Decimal_integerContext,0)


        def use16(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Use16Context,0)


        def use32(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Use32Context,0)


        def default(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.DefaultContext,0)


        def default_perfix(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Default_perfixContext,0)


        def section(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.SectionContext,0)


        def section_params(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Section_paramsContext,0)


        def absolute(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.AbsoluteContext,0)


        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.NameContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,i)


        def extern_params(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Extern_paramsContext,0)


        def extern(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExternContext,0)


        def required(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.RequiredContext,0)


        def global_(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.GlobalContext,0)


        def global_params(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Global_paramsContext,0)


        def common(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.CommonContext,0)


        def common_params(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Common_paramsContext,0)


        def static(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.StaticContext,0)


        def cpu(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.CpuContext,0)


        def float_name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Float_nameContext,0)


        def float_params(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Float_paramsContext,0)


        def LEFT_BRACKET(self):
            return self.getToken(nasm_x86_64_Parser.LEFT_BRACKET, 0)

        def RIGHT_BRACKET(self):
            return self.getToken(nasm_x86_64_Parser.RIGHT_BRACKET, 0)

        def warning(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.WarningContext,0)


        def warning_class(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Warning_classContext,0)


        def map_(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.MapContext,0)


        def map_type(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Map_typeContext,0)


        def warning_state(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Warning_stateContext,0)


        def org(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.OrgContext,0)


        def group(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.GroupContext,0)


        def import_rule(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Import_ruleContext,0)


        def uppercase(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.UppercaseContext,0)


        def export(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExportContext,0)


        def export_params(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Export_paramsContext,0)


        def safeseh(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.SafesehContext,0)


        def osabi(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.OsabiContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_directive

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDirective" ):
                listener.enterDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDirective" ):
                listener.exitDirective(self)




    def directive(self):

        localctx = nasm_x86_64_Parser.DirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_directive)
        self._la = 0 # Token type
        try:
            self.state = 315
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2522]:
                self.enterOuterAlt(localctx, 1)
                self.state = 236
                self.bits()
                self.state = 237
                self.decimal_integer()
                pass
            elif token in [2523]:
                self.enterOuterAlt(localctx, 2)
                self.state = 239
                self.use16()
                pass
            elif token in [2524]:
                self.enterOuterAlt(localctx, 3)
                self.state = 240
                self.use32()
                pass
            elif token in [2525]:
                self.enterOuterAlt(localctx, 4)
                self.state = 241
                self.default()
                self.state = 242
                self.default_perfix()
                pass
            elif token in [2531, 2533]:
                self.enterOuterAlt(localctx, 5)
                self.state = 244
                self.section()
                self.state = 245
                self.section_params()
                pass
            elif token in [2534]:
                self.enterOuterAlt(localctx, 6)
                self.state = 247
                self.absolute()
                self.state = 250
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2613, 2615, 2616, 2617]:
                    self.state = 248
                    self.integer()
                    pass
                elif token in [2622]:
                    self.state = 249
                    self.name()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [2535, 2536]:
                self.enterOuterAlt(localctx, 7)
                self.state = 254
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2535]:
                    self.state = 252
                    self.extern()
                    pass
                elif token in [2536]:
                    self.state = 253
                    self.required()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 256
                self.extern_params()
                pass
            elif token in [2537]:
                self.enterOuterAlt(localctx, 8)
                self.state = 258
                self.global_()
                self.state = 259
                self.global_params()
                pass
            elif token in [2538]:
                self.enterOuterAlt(localctx, 9)
                self.state = 261
                self.common()
                self.state = 262
                self.common_params()
                pass
            elif token in [2541]:
                self.enterOuterAlt(localctx, 10)
                self.state = 264
                self.static()
                self.state = 265
                self.name()
                pass
            elif token in [2542]:
                self.enterOuterAlt(localctx, 11)
                self.state = 267
                self.cpu()
                self.state = 270
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2613]:
                    self.state = 268
                    self.decimal_integer()
                    pass
                elif token in [2622]:
                    self.state = 269
                    self.name()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [2543]:
                self.enterOuterAlt(localctx, 12)
                self.state = 272
                self.float_name()
                self.state = 273
                self.float_params()
                pass
            elif token in [31]:
                self.enterOuterAlt(localctx, 13)
                self.state = 275
                self.match(nasm_x86_64_Parser.LEFT_BRACKET)
                self.state = 286
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2549]:
                    self.state = 276
                    self.warning()
                    self.state = 278
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & 63050394783186944) != 0):
                        self.state = 277
                        self.warning_state()


                    self.state = 280
                    self.warning_class()
                    pass
                elif token in [2558]:
                    self.state = 282
                    self.map_()
                    self.state = 283
                    self.map_type()
                    self.state = 284
                    self.name()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 288
                self.match(nasm_x86_64_Parser.RIGHT_BRACKET)
                pass
            elif token in [2550]:
                self.enterOuterAlt(localctx, 14)
                self.state = 290
                self.org()
                self.state = 291
                self.integer()
                pass
            elif token in [2568, 2570]:
                self.enterOuterAlt(localctx, 15)
                self.state = 298
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2568]:
                    self.state = 293
                    self.group()
                    self.state = 294
                    self.name()
                    self.state = 295
                    self.name()
                    pass
                elif token in [2570]:
                    self.state = 297
                    self.import_rule()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 301 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 300
                    self.name()
                    self.state = 303 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==2622):
                        break

                pass
            elif token in [2569]:
                self.enterOuterAlt(localctx, 16)
                self.state = 305
                self.uppercase()
                pass
            elif token in [2571]:
                self.enterOuterAlt(localctx, 17)
                self.state = 306
                self.export()
                self.state = 307
                self.export_params()
                pass
            elif token in [2582]:
                self.enterOuterAlt(localctx, 18)
                self.state = 309
                self.safeseh()
                self.state = 310
                self.name()
                pass
            elif token in [2589]:
                self.enterOuterAlt(localctx, 19)
                self.state = 312
                self.osabi()
                self.state = 313
                self.decimal_integer()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BitsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BITS(self):
            return self.getToken(nasm_x86_64_Parser.BITS, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_bits

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBits" ):
                listener.enterBits(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBits" ):
                listener.exitBits(self)




    def bits(self):

        localctx = nasm_x86_64_Parser.BitsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_bits)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            self.match(nasm_x86_64_Parser.BITS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Decimal_integerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DECIMAL_INTEGER(self):
            return self.getToken(nasm_x86_64_Parser.DECIMAL_INTEGER, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_decimal_integer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDecimal_integer" ):
                listener.enterDecimal_integer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDecimal_integer" ):
                listener.exitDecimal_integer(self)




    def decimal_integer(self):

        localctx = nasm_x86_64_Parser.Decimal_integerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_decimal_integer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self.match(nasm_x86_64_Parser.DECIMAL_INTEGER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Use16Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def USE16(self):
            return self.getToken(nasm_x86_64_Parser.USE16, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_use16

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUse16" ):
                listener.enterUse16(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUse16" ):
                listener.exitUse16(self)




    def use16(self):

        localctx = nasm_x86_64_Parser.Use16Context(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_use16)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 321
            self.match(nasm_x86_64_Parser.USE16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Use32Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def USE32(self):
            return self.getToken(nasm_x86_64_Parser.USE32, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_use32

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUse32" ):
                listener.enterUse32(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUse32" ):
                listener.exitUse32(self)




    def use32(self):

        localctx = nasm_x86_64_Parser.Use32Context(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_use32)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 323
            self.match(nasm_x86_64_Parser.USE32)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DefaultContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DEFAULT(self):
            return self.getToken(nasm_x86_64_Parser.DEFAULT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_default

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefault" ):
                listener.enterDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefault" ):
                listener.exitDefault(self)




    def default(self):

        localctx = nasm_x86_64_Parser.DefaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_default)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 325
            self.match(nasm_x86_64_Parser.DEFAULT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Default_perfixContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REL(self):
            return self.getToken(nasm_x86_64_Parser.REL, 0)

        def ABS(self):
            return self.getToken(nasm_x86_64_Parser.ABS, 0)

        def BND(self):
            return self.getToken(nasm_x86_64_Parser.BND, 0)

        def NOBND(self):
            return self.getToken(nasm_x86_64_Parser.NOBND, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_default_perfix

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefault_perfix" ):
                listener.enterDefault_perfix(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefault_perfix" ):
                listener.exitDefault_perfix(self)




    def default_perfix(self):

        localctx = nasm_x86_64_Parser.Default_perfixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_default_perfix)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            _la = self._input.LA(1)
            if not(((((_la - 2526)) & ~0x3f) == 0 and ((1 << (_la - 2526)) & 15) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SectionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SECTION(self):
            return self.getToken(nasm_x86_64_Parser.SECTION, 0)

        def SEGMENT(self):
            return self.getToken(nasm_x86_64_Parser.SEGMENT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_section

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSection" ):
                listener.enterSection(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSection" ):
                listener.exitSection(self)




    def section(self):

        localctx = nasm_x86_64_Parser.SectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_section)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 329
            _la = self._input.LA(1)
            if not(_la==2531 or _la==2533):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Section_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def attribute(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.AttributeContext,0)


        def section_type(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Section_typeContext,0)


        def class_(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ClassContext,0)


        def overlay(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.OverlayContext,0)


        def designation(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.DesignationContext,0)


        def allocation(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.AllocationContext,0)


        def execution(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExecutionContext,0)


        def writing(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.WritingContext,0)


        def starting_possition(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Starting_possitionContext,0)


        def follow(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.FollowContext,0)


        def use16(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Use16Context,0)


        def use32(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Use32Context,0)


        def flat(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.FlatContext,0)


        def absolute_seg(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Absolute_segContext,0)


        def alingment(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.AlingmentContext,0)


        def comdat(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ComdatContext,0)


        def tls(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.TlsContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_section_params

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSection_params" ):
                listener.enterSection_params(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSection_params" ):
                listener.exitSection_params(self)




    def section_params(self):

        localctx = nasm_x86_64_Parser.Section_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_section_params)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 331
            self.name()
            self.state = 333
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 2538)) & ~0x3f) == 0 and ((1 << (_la - 2538)) & 117440513) != 0):
                self.state = 332
                self.attribute()


            self.state = 336
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 2575)) & ~0x3f) == 0 and ((1 << (_la - 2575)) & 16191) != 0):
                self.state = 335
                self.section_type()


            self.state = 339
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2565:
                self.state = 338
                self.class_()


            self.state = 342
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2566:
                self.state = 341
                self.overlay()


            self.state = 345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 2554)) & ~0x3f) == 0 and ((1 << (_la - 2554)) & 1030792151043) != 0):
                self.state = 344
                self.designation()


            self.state = 348
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2596 or _la==2597:
                self.state = 347
                self.allocation()


            self.state = 351
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2598 or _la==2599:
                self.state = 350
                self.execution()


            self.state = 354
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2600 or _la==2601:
                self.state = 353
                self.writing()


            self.state = 357
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2552:
                self.state = 356
                self.starting_possition()


            self.state = 360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2556 or _la==2557:
                self.state = 359
                self.follow()


            self.state = 364
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2523]:
                self.state = 362
                self.use16()
                pass
            elif token in [2524]:
                self.state = 363
                self.use32()
                pass
            elif token in [2534, 2551, 2553, 2567, 2581, 2594, 2595, 2626]:
                pass
            else:
                pass
            self.state = 367
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2567:
                self.state = 366
                self.flat()


            self.state = 371
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2534]:
                self.state = 369
                self.absolute_seg()
                pass
            elif token in [2551, 2553, 2595]:
                self.state = 370
                self.alingment()
                pass
            elif token in [2581, 2594, 2626]:
                pass
            else:
                pass
            self.state = 374
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2581:
                self.state = 373
                self.comdat()


            self.state = 377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2594:
                self.state = 376
                self.tls()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NAME(self):
            return self.getToken(nasm_x86_64_Parser.NAME, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterName" ):
                listener.enterName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitName" ):
                listener.exitName(self)




    def name(self):

        localctx = nasm_x86_64_Parser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 379
            self.match(nasm_x86_64_Parser.NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PRIVATE(self):
            return self.getToken(nasm_x86_64_Parser.PRIVATE, 0)

        def PUBLIC(self):
            return self.getToken(nasm_x86_64_Parser.PUBLIC, 0)

        def COMMON(self):
            return self.getToken(nasm_x86_64_Parser.COMMON, 0)

        def STACK(self):
            return self.getToken(nasm_x86_64_Parser.STACK, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_attribute

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute" ):
                listener.enterAttribute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute" ):
                listener.exitAttribute(self)




    def attribute(self):

        localctx = nasm_x86_64_Parser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 381
            _la = self._input.LA(1)
            if not(((((_la - 2538)) & ~0x3f) == 0 and ((1 << (_la - 2538)) & 117440513) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Section_typeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CODE(self):
            return self.getToken(nasm_x86_64_Parser.CODE, 0)

        def TEXT(self):
            return self.getToken(nasm_x86_64_Parser.TEXT, 0)

        def DATA(self):
            return self.getToken(nasm_x86_64_Parser.DATA, 0)

        def BSS(self):
            return self.getToken(nasm_x86_64_Parser.BSS, 0)

        def RDATA(self):
            return self.getToken(nasm_x86_64_Parser.RDATA, 0)

        def INFO(self):
            return self.getToken(nasm_x86_64_Parser.INFO, 0)

        def MIXED(self):
            return self.getToken(nasm_x86_64_Parser.MIXED, 0)

        def ZEROFILL(self):
            return self.getToken(nasm_x86_64_Parser.ZEROFILL, 0)

        def NO_DEAD_STRIP(self):
            return self.getToken(nasm_x86_64_Parser.NO_DEAD_STRIP, 0)

        def LIVE_SUPPORT(self):
            return self.getToken(nasm_x86_64_Parser.LIVE_SUPPORT, 0)

        def STRIP_STATIC_SYMS(self):
            return self.getToken(nasm_x86_64_Parser.STRIP_STATIC_SYMS, 0)

        def DEBUG(self):
            return self.getToken(nasm_x86_64_Parser.DEBUG, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_section_type

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSection_type" ):
                listener.enterSection_type(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSection_type" ):
                listener.exitSection_type(self)




    def section_type(self):

        localctx = nasm_x86_64_Parser.Section_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_section_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 383
            _la = self._input.LA(1)
            if not(((((_la - 2575)) & ~0x3f) == 0 and ((1 << (_la - 2575)) & 16191) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CLASS_(self):
            return self.getToken(nasm_x86_64_Parser.CLASS_, 0)

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_class

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass" ):
                listener.enterClass(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass" ):
                listener.exitClass(self)




    def class_(self):

        localctx = nasm_x86_64_Parser.ClassContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_class)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 385
            self.match(nasm_x86_64_Parser.CLASS_)
            self.state = 386
            self.match(nasm_x86_64_Parser.EQUAL_1)
            self.state = 387
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OverlayContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OVERLAY(self):
            return self.getToken(nasm_x86_64_Parser.OVERLAY, 0)

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_overlay

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOverlay" ):
                listener.enterOverlay(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOverlay" ):
                listener.exitOverlay(self)




    def overlay(self):

        localctx = nasm_x86_64_Parser.OverlayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_overlay)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 389
            self.match(nasm_x86_64_Parser.OVERLAY)
            self.state = 390
            self.match(nasm_x86_64_Parser.EQUAL_1)
            self.state = 391
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DesignationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROGBITS(self):
            return self.getToken(nasm_x86_64_Parser.PROGBITS, 0)

        def NOBITS(self):
            return self.getToken(nasm_x86_64_Parser.NOBITS, 0)

        def NOTE(self):
            return self.getToken(nasm_x86_64_Parser.NOTE, 0)

        def PREINIT_ARRAY(self):
            return self.getToken(nasm_x86_64_Parser.PREINIT_ARRAY, 0)

        def INIT_ARRAY(self):
            return self.getToken(nasm_x86_64_Parser.INIT_ARRAY, 0)

        def FINI_ARRAY(self):
            return self.getToken(nasm_x86_64_Parser.FINI_ARRAY, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_designation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDesignation" ):
                listener.enterDesignation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDesignation" ):
                listener.exitDesignation(self)




    def designation(self):

        localctx = nasm_x86_64_Parser.DesignationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_designation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 393
            _la = self._input.LA(1)
            if not(((((_la - 2554)) & ~0x3f) == 0 and ((1 << (_la - 2554)) & 1030792151043) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AllocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ALLOC(self):
            return self.getToken(nasm_x86_64_Parser.ALLOC, 0)

        def NOALLOC(self):
            return self.getToken(nasm_x86_64_Parser.NOALLOC, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_allocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAllocation" ):
                listener.enterAllocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAllocation" ):
                listener.exitAllocation(self)




    def allocation(self):

        localctx = nasm_x86_64_Parser.AllocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_allocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 395
            _la = self._input.LA(1)
            if not(_la==2596 or _la==2597):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExecutionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EXEC(self):
            return self.getToken(nasm_x86_64_Parser.EXEC, 0)

        def NOEXEC(self):
            return self.getToken(nasm_x86_64_Parser.NOEXEC, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_execution

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExecution" ):
                listener.enterExecution(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExecution" ):
                listener.exitExecution(self)




    def execution(self):

        localctx = nasm_x86_64_Parser.ExecutionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_execution)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 397
            _la = self._input.LA(1)
            if not(_la==2598 or _la==2599):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WritingContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WRITE(self):
            return self.getToken(nasm_x86_64_Parser.WRITE, 0)

        def NOWRITE(self):
            return self.getToken(nasm_x86_64_Parser.NOWRITE, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_writing

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWriting" ):
                listener.enterWriting(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWriting" ):
                listener.exitWriting(self)




    def writing(self):

        localctx = nasm_x86_64_Parser.WritingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_writing)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            _la = self._input.LA(1)
            if not(_la==2600 or _la==2601):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Starting_possitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def VSTART(self):
            return self.getToken(nasm_x86_64_Parser.VSTART, 0)

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_starting_possition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStarting_possition" ):
                listener.enterStarting_possition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStarting_possition" ):
                listener.exitStarting_possition(self)




    def starting_possition(self):

        localctx = nasm_x86_64_Parser.Starting_possitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_starting_possition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 401
            self.match(nasm_x86_64_Parser.VSTART)
            self.state = 402
            self.match(nasm_x86_64_Parser.EQUAL_1)
            self.state = 403
            self.integer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FollowContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def FOLLOWS(self):
            return self.getToken(nasm_x86_64_Parser.FOLLOWS, 0)

        def VFOLLOWS(self):
            return self.getToken(nasm_x86_64_Parser.VFOLLOWS, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_follow

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFollow" ):
                listener.enterFollow(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFollow" ):
                listener.exitFollow(self)




    def follow(self):

        localctx = nasm_x86_64_Parser.FollowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_follow)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 405
            _la = self._input.LA(1)
            if not(_la==2556 or _la==2557):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 406
            self.match(nasm_x86_64_Parser.EQUAL_1)
            self.state = 407
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FlatContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FLAT(self):
            return self.getToken(nasm_x86_64_Parser.FLAT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_flat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFlat" ):
                listener.enterFlat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFlat" ):
                listener.exitFlat(self)




    def flat(self):

        localctx = nasm_x86_64_Parser.FlatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_flat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 409
            self.match(nasm_x86_64_Parser.FLAT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Absolute_segContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ABSOLUTE(self):
            return self.getToken(nasm_x86_64_Parser.ABSOLUTE, 0)

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_absolute_seg

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAbsolute_seg" ):
                listener.enterAbsolute_seg(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAbsolute_seg" ):
                listener.exitAbsolute_seg(self)




    def absolute_seg(self):

        localctx = nasm_x86_64_Parser.Absolute_segContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_absolute_seg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 411
            self.match(nasm_x86_64_Parser.ABSOLUTE)
            self.state = 412
            self.match(nasm_x86_64_Parser.EQUAL_1)
            self.state = 413
            self.integer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AlingmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def ALIGN(self):
            return self.getToken(nasm_x86_64_Parser.ALIGN, 0)

        def START(self):
            return self.getToken(nasm_x86_64_Parser.START, 0)

        def POINTER(self):
            return self.getToken(nasm_x86_64_Parser.POINTER, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_alingment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAlingment" ):
                listener.enterAlingment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAlingment" ):
                listener.exitAlingment(self)




    def alingment(self):

        localctx = nasm_x86_64_Parser.AlingmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_alingment)
        self._la = 0 # Token type
        try:
            self.state = 419
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2551, 2553]:
                self.enterOuterAlt(localctx, 1)
                self.state = 415
                _la = self._input.LA(1)
                if not(_la==2551 or _la==2553):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 416
                self.match(nasm_x86_64_Parser.EQUAL_1)
                self.state = 417
                self.integer()
                pass
            elif token in [2595]:
                self.enterOuterAlt(localctx, 2)
                self.state = 418
                self.match(nasm_x86_64_Parser.POINTER)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComdatContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COMDAT(self):
            return self.getToken(nasm_x86_64_Parser.COMDAT, 0)

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_comdat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComdat" ):
                listener.enterComdat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComdat" ):
                listener.exitComdat(self)




    def comdat(self):

        localctx = nasm_x86_64_Parser.ComdatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_comdat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 421
            self.match(nasm_x86_64_Parser.COMDAT)
            self.state = 422
            self.match(nasm_x86_64_Parser.EQUAL_1)
            self.state = 423
            self.integer()
            self.state = 424
            self.match(nasm_x86_64_Parser.COLON)
            self.state = 425
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TlsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TLS(self):
            return self.getToken(nasm_x86_64_Parser.TLS, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_tls

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTls" ):
                listener.enterTls(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTls" ):
                listener.exitTls(self)




    def tls(self):

        localctx = nasm_x86_64_Parser.TlsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_tls)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 427
            self.match(nasm_x86_64_Parser.TLS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AbsoluteContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ABSOLUTE(self):
            return self.getToken(nasm_x86_64_Parser.ABSOLUTE, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_absolute

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAbsolute" ):
                listener.enterAbsolute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAbsolute" ):
                listener.exitAbsolute(self)




    def absolute(self):

        localctx = nasm_x86_64_Parser.AbsoluteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_absolute)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429
            self.match(nasm_x86_64_Parser.ABSOLUTE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntegerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DECIMAL_INTEGER(self):
            return self.getToken(nasm_x86_64_Parser.DECIMAL_INTEGER, 0)

        def OCT_INTEGER(self):
            return self.getToken(nasm_x86_64_Parser.OCT_INTEGER, 0)

        def HEX_INTEGER(self):
            return self.getToken(nasm_x86_64_Parser.HEX_INTEGER, 0)

        def BIN_INTEGER(self):
            return self.getToken(nasm_x86_64_Parser.BIN_INTEGER, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_integer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInteger" ):
                listener.enterInteger(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInteger" ):
                listener.exitInteger(self)




    def integer(self):

        localctx = nasm_x86_64_Parser.IntegerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_integer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 431
            _la = self._input.LA(1)
            if not(((((_la - 2613)) & ~0x3f) == 0 and ((1 << (_la - 2613)) & 29) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExternContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EXTERN(self):
            return self.getToken(nasm_x86_64_Parser.EXTERN, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_extern

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExtern" ):
                listener.enterExtern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExtern" ):
                listener.exitExtern(self)




    def extern(self):

        localctx = nasm_x86_64_Parser.ExternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_extern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 433
            self.match(nasm_x86_64_Parser.EXTERN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Extern_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COMMA)
            else:
                return self.getToken(nasm_x86_64_Parser.COMMA, i)

        def extern_params(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.Extern_paramsContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.Extern_paramsContext,i)


        def wrt(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.WrtContext,0)


        def weak(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.WeakContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_extern_params

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExtern_params" ):
                listener.enterExtern_params(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExtern_params" ):
                listener.exitExtern_params(self)




    def extern_params(self):

        localctx = nasm_x86_64_Parser.Extern_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_extern_params)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 435
            self.name()
            self.state = 441
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==33:
                self.state = 436
                self.match(nasm_x86_64_Parser.COLON)
                self.state = 439
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2602, 2622]:
                    self.state = 437
                    self.wrt()
                    pass
                elif token in [2605]:
                    self.state = 438
                    self.weak()
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 447
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,31,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 443
                    self.match(nasm_x86_64_Parser.COMMA)
                    self.state = 444
                    self.extern_params() 
                self.state = 449
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,31,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WrtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WRT(self):
            return self.getToken(nasm_x86_64_Parser.WRT, 0)

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.NameContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,i)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_wrt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWrt" ):
                listener.enterWrt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWrt" ):
                listener.exitWrt(self)




    def wrt(self):

        localctx = nasm_x86_64_Parser.WrtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_wrt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2622:
                self.state = 450
                self.name()


            self.state = 453
            self.match(nasm_x86_64_Parser.WRT)
            self.state = 454
            self.name()
            self.state = 457
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==33:
                self.state = 455
                self.match(nasm_x86_64_Parser.COLON)
                self.state = 456
                self.integer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WeakContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WEAK(self):
            return self.getToken(nasm_x86_64_Parser.WEAK, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_weak

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWeak" ):
                listener.enterWeak(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWeak" ):
                listener.exitWeak(self)




    def weak(self):

        localctx = nasm_x86_64_Parser.WeakContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_weak)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self.match(nasm_x86_64_Parser.WEAK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RequiredContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REQUIRED(self):
            return self.getToken(nasm_x86_64_Parser.REQUIRED, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_required

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRequired" ):
                listener.enterRequired(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRequired" ):
                listener.exitRequired(self)




    def required(self):

        localctx = nasm_x86_64_Parser.RequiredContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_required)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 461
            self.match(nasm_x86_64_Parser.REQUIRED)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GlobalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GLOBAL(self):
            return self.getToken(nasm_x86_64_Parser.GLOBAL, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_global

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal" ):
                listener.enterGlobal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal" ):
                listener.exitGlobal(self)




    def global_(self):

        localctx = nasm_x86_64_Parser.GlobalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_global)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 463
            self.match(nasm_x86_64_Parser.GLOBAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Global_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def global_type(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Global_typeContext,0)


        def visibility(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.VisibilityContext,0)


        def binding(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.BindingContext,0)


        def expression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExpressionContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COMMA)
            else:
                return self.getToken(nasm_x86_64_Parser.COMMA, i)

        def global_params(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.Global_paramsContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.Global_paramsContext,i)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_global_params

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal_params" ):
                listener.enterGlobal_params(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal_params" ):
                listener.exitGlobal_params(self)




    def global_params(self):

        localctx = nasm_x86_64_Parser.Global_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_global_params)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            self.name()
            self.state = 468
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==33:
                self.state = 466
                self.match(nasm_x86_64_Parser.COLON)
                self.state = 467
                self.global_type()


            self.state = 471
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2525 or ((((_la - 2607)) & ~0x3f) == 0 and ((1 << (_la - 2607)) & 7) != 0):
                self.state = 470
                self.visibility()


            self.state = 474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2605 or _la==2606:
                self.state = 473
                self.binding()


            self.state = 477
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -1125899906305753088) != 0) or ((((_la - 560)) & ~0x3f) == 0 and ((1 << (_la - 560)) & -1) != 0) or ((((_la - 624)) & ~0x3f) == 0 and ((1 << (_la - 624)) & -1) != 0) or ((((_la - 688)) & ~0x3f) == 0 and ((1 << (_la - 688)) & -1) != 0) or ((((_la - 752)) & ~0x3f) == 0 and ((1 << (_la - 752)) & 576460752303423487) != 0) or ((((_la - 2612)) & ~0x3f) == 0 and ((1 << (_la - 2612)) & 1147) != 0):
                self.state = 476
                self.expression()


            self.state = 483
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,38,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 479
                    self.match(nasm_x86_64_Parser.COMMA)
                    self.state = 480
                    self.global_params() 
                self.state = 485
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,38,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Global_typeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FUNCTION(self):
            return self.getToken(nasm_x86_64_Parser.FUNCTION, 0)

        def DATA(self):
            return self.getToken(nasm_x86_64_Parser.DATA, 0)

        def OBJECT(self):
            return self.getToken(nasm_x86_64_Parser.OBJECT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_global_type

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal_type" ):
                listener.enterGlobal_type(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal_type" ):
                listener.exitGlobal_type(self)




    def global_type(self):

        localctx = nasm_x86_64_Parser.Global_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_global_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 486
            _la = self._input.LA(1)
            if not(((((_la - 2578)) & ~0x3f) == 0 and ((1 << (_la - 2578)) & 100663297) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VisibilityContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DEFAULT(self):
            return self.getToken(nasm_x86_64_Parser.DEFAULT, 0)

        def INTERNAL(self):
            return self.getToken(nasm_x86_64_Parser.INTERNAL, 0)

        def HIDDEN_(self):
            return self.getToken(nasm_x86_64_Parser.HIDDEN_, 0)

        def PROTECTED(self):
            return self.getToken(nasm_x86_64_Parser.PROTECTED, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_visibility

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVisibility" ):
                listener.enterVisibility(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVisibility" ):
                listener.exitVisibility(self)




    def visibility(self):

        localctx = nasm_x86_64_Parser.VisibilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 488
            _la = self._input.LA(1)
            if not(_la==2525 or ((((_la - 2607)) & ~0x3f) == 0 and ((1 << (_la - 2607)) & 7) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BindingContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WEAK(self):
            return self.getToken(nasm_x86_64_Parser.WEAK, 0)

        def STRONG(self):
            return self.getToken(nasm_x86_64_Parser.STRONG, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_binding

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBinding" ):
                listener.enterBinding(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBinding" ):
                listener.exitBinding(self)




    def binding(self):

        localctx = nasm_x86_64_Parser.BindingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_binding)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 490
            _la = self._input.LA(1)
            if not(_la==2605 or _la==2606):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CommonContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COMMON(self):
            return self.getToken(nasm_x86_64_Parser.COMMON, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_common

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommon" ):
                listener.enterCommon(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommon" ):
                listener.exitCommon(self)




    def common(self):

        localctx = nasm_x86_64_Parser.CommonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_common)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self.match(nasm_x86_64_Parser.COMMON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Common_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def integer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.IntegerContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,i)


        def COLON(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COLON)
            else:
                return self.getToken(nasm_x86_64_Parser.COLON, i)

        def near(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.NearContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.NearContext,i)


        def far(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.FarContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.FarContext,i)


        def wrt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.WrtContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.WrtContext,i)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_common_params

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommon_params" ):
                listener.enterCommon_params(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommon_params" ):
                listener.exitCommon_params(self)




    def common_params(self):

        localctx = nasm_x86_64_Parser.Common_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_common_params)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 494
            self.name()
            self.state = 505 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 495
                    self.integer()
                    self.state = 503
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==33:
                        self.state = 496
                        self.match(nasm_x86_64_Parser.COLON)
                        self.state = 501
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [2539]:
                            self.state = 497
                            self.near()
                            pass
                        elif token in [2540]:
                            self.state = 498
                            self.far()
                            pass
                        elif token in [2613, 2615, 2616, 2617]:
                            self.state = 499
                            self.integer()
                            pass
                        elif token in [2602, 2622]:
                            self.state = 500
                            self.wrt()
                            pass
                        else:
                            raise NoViableAltException(self)




                else:
                    raise NoViableAltException(self)
                self.state = 507 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,self._ctx)

            self.state = 510
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 2613)) & ~0x3f) == 0 and ((1 << (_la - 2613)) & 29) != 0):
                self.state = 509
                self.integer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NearContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEAR(self):
            return self.getToken(nasm_x86_64_Parser.NEAR, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_near

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNear" ):
                listener.enterNear(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNear" ):
                listener.exitNear(self)




    def near(self):

        localctx = nasm_x86_64_Parser.NearContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_near)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 512
            self.match(nasm_x86_64_Parser.NEAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FarContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FAR(self):
            return self.getToken(nasm_x86_64_Parser.FAR, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_far

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFar" ):
                listener.enterFar(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFar" ):
                listener.exitFar(self)




    def far(self):

        localctx = nasm_x86_64_Parser.FarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_far)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 514
            self.match(nasm_x86_64_Parser.FAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StaticContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STATIC(self):
            return self.getToken(nasm_x86_64_Parser.STATIC, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_static

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatic" ):
                listener.enterStatic(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatic" ):
                listener.exitStatic(self)




    def static(self):

        localctx = nasm_x86_64_Parser.StaticContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_static)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 516
            self.match(nasm_x86_64_Parser.STATIC)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CpuContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CPU(self):
            return self.getToken(nasm_x86_64_Parser.CPU, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_cpu

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCpu" ):
                listener.enterCpu(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCpu" ):
                listener.exitCpu(self)




    def cpu(self):

        localctx = nasm_x86_64_Parser.CpuContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_cpu)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 518
            self.match(nasm_x86_64_Parser.CPU)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Float_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FLOAT_NAME(self):
            return self.getToken(nasm_x86_64_Parser.FLOAT_NAME, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_float_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFloat_name" ):
                listener.enterFloat_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFloat_name" ):
                listener.exitFloat_name(self)




    def float_name(self):

        localctx = nasm_x86_64_Parser.Float_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_float_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 520
            self.match(nasm_x86_64_Parser.FLOAT_NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Float_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DAZ(self):
            return self.getToken(nasm_x86_64_Parser.DAZ, 0)

        def NODAZ(self):
            return self.getToken(nasm_x86_64_Parser.NODAZ, 0)

        def NEAR(self):
            return self.getToken(nasm_x86_64_Parser.NEAR, 0)

        def UP(self):
            return self.getToken(nasm_x86_64_Parser.UP, 0)

        def DOWN(self):
            return self.getToken(nasm_x86_64_Parser.DOWN, 0)

        def ZERO(self):
            return self.getToken(nasm_x86_64_Parser.ZERO, 0)

        def DEFAULT(self):
            return self.getToken(nasm_x86_64_Parser.DEFAULT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_float_params

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFloat_params" ):
                listener.enterFloat_params(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFloat_params" ):
                listener.exitFloat_params(self)




    def float_params(self):

        localctx = nasm_x86_64_Parser.Float_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_float_params)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 522
            _la = self._input.LA(1)
            if not(((((_la - 2525)) & ~0x3f) == 0 and ((1 << (_la - 2525)) & 16269313) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WarningContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WARNING(self):
            return self.getToken(nasm_x86_64_Parser.WARNING, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_warning

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWarning" ):
                listener.enterWarning(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWarning" ):
                listener.exitWarning(self)




    def warning(self):

        localctx = nasm_x86_64_Parser.WarningContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_warning)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 524
            self.match(nasm_x86_64_Parser.WARNING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Warning_stateContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PLUS(self):
            return self.getToken(nasm_x86_64_Parser.PLUS, 0)

        def MINUS(self):
            return self.getToken(nasm_x86_64_Parser.MINUS, 0)

        def MULTIPLICATION(self):
            return self.getToken(nasm_x86_64_Parser.MULTIPLICATION, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_warning_state

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWarning_state" ):
                listener.enterWarning_state(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWarning_state" ):
                listener.exitWarning_state(self)




    def warning_state(self):

        localctx = nasm_x86_64_Parser.Warning_stateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_warning_state)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 526
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 63050394783186944) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Warning_classContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def warning_name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Warning_nameContext,0)


        def push(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.PushContext,0)


        def pop(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.PopContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_warning_class

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWarning_class" ):
                listener.enterWarning_class(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWarning_class" ):
                listener.exitWarning_class(self)




    def warning_class(self):

        localctx = nasm_x86_64_Parser.Warning_classContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_warning_class)
        try:
            self.state = 531
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2621, 2622]:
                self.enterOuterAlt(localctx, 1)
                self.state = 528
                self.warning_name()
                pass
            elif token in [438]:
                self.enterOuterAlt(localctx, 2)
                self.state = 529
                self.push()
                pass
            elif token in [405]:
                self.enterOuterAlt(localctx, 3)
                self.state = 530
                self.pop()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Warning_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WARNING_NAME(self):
            return self.getToken(nasm_x86_64_Parser.WARNING_NAME, 0)

        def NAME(self):
            return self.getToken(nasm_x86_64_Parser.NAME, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_warning_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWarning_name" ):
                listener.enterWarning_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWarning_name" ):
                listener.exitWarning_name(self)




    def warning_name(self):

        localctx = nasm_x86_64_Parser.Warning_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_warning_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 533
            _la = self._input.LA(1)
            if not(_la==2621 or _la==2622):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PushContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PUSH(self):
            return self.getToken(nasm_x86_64_Parser.PUSH, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_push

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPush" ):
                listener.enterPush(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPush" ):
                listener.exitPush(self)




    def push(self):

        localctx = nasm_x86_64_Parser.PushContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_push)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 535
            self.match(nasm_x86_64_Parser.PUSH)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PopContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def POP(self):
            return self.getToken(nasm_x86_64_Parser.POP, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_pop

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPop" ):
                listener.enterPop(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPop" ):
                listener.exitPop(self)




    def pop(self):

        localctx = nasm_x86_64_Parser.PopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_pop)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 537
            self.match(nasm_x86_64_Parser.POP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OrgContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ORG(self):
            return self.getToken(nasm_x86_64_Parser.ORG, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_org

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOrg" ):
                listener.enterOrg(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOrg" ):
                listener.exitOrg(self)




    def org(self):

        localctx = nasm_x86_64_Parser.OrgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_org)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            self.match(nasm_x86_64_Parser.ORG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MapContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MAP(self):
            return self.getToken(nasm_x86_64_Parser.MAP, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_map

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMap" ):
                listener.enterMap(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMap" ):
                listener.exitMap(self)




    def map_(self):

        localctx = nasm_x86_64_Parser.MapContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_map)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 541
            self.match(nasm_x86_64_Parser.MAP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Map_typeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ALL(self):
            return self.getToken(nasm_x86_64_Parser.ALL, 0)

        def BRIEF(self):
            return self.getToken(nasm_x86_64_Parser.BRIEF, 0)

        def SECTIONS(self):
            return self.getToken(nasm_x86_64_Parser.SECTIONS, 0)

        def SEGMENTS(self):
            return self.getToken(nasm_x86_64_Parser.SEGMENTS, 0)

        def SYMBOLS(self):
            return self.getToken(nasm_x86_64_Parser.SYMBOLS, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_map_type

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMap_type" ):
                listener.enterMap_type(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMap_type" ):
                listener.exitMap_type(self)




    def map_type(self):

        localctx = nasm_x86_64_Parser.Map_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_map_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 543
            _la = self._input.LA(1)
            if not(((((_la - 2530)) & ~0x3f) == 0 and ((1 << (_la - 2530)) & 3758096389) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GroupContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GROUP(self):
            return self.getToken(nasm_x86_64_Parser.GROUP, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_group

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGroup" ):
                listener.enterGroup(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGroup" ):
                listener.exitGroup(self)




    def group(self):

        localctx = nasm_x86_64_Parser.GroupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_group)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 545
            self.match(nasm_x86_64_Parser.GROUP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UppercaseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UPPERCASE(self):
            return self.getToken(nasm_x86_64_Parser.UPPERCASE, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_uppercase

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUppercase" ):
                listener.enterUppercase(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUppercase" ):
                listener.exitUppercase(self)




    def uppercase(self):

        localctx = nasm_x86_64_Parser.UppercaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_uppercase)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 547
            self.match(nasm_x86_64_Parser.UPPERCASE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Import_ruleContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IMPORT(self):
            return self.getToken(nasm_x86_64_Parser.IMPORT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_import_rule

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImport_rule" ):
                listener.enterImport_rule(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImport_rule" ):
                listener.exitImport_rule(self)




    def import_rule(self):

        localctx = nasm_x86_64_Parser.Import_ruleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_import_rule)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 549
            self.match(nasm_x86_64_Parser.IMPORT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExportContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EXPORT(self):
            return self.getToken(nasm_x86_64_Parser.EXPORT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_export

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExport" ):
                listener.enterExport(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExport" ):
                listener.exitExport(self)




    def export(self):

        localctx = nasm_x86_64_Parser.ExportContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_export)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551
            self.match(nasm_x86_64_Parser.EXPORT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Export_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.NameContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,i)


        def resident(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.ResidentContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.ResidentContext,i)


        def nodata(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.NodataContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.NodataContext,i)


        def parm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.ParmContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.ParmContext,i)


        def integer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.IntegerContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,i)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_export_params

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExport_params" ):
                listener.enterExport_params(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExport_params" ):
                listener.exitExport_params(self)




    def export_params(self):

        localctx = nasm_x86_64_Parser.Export_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_export_params)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 553
            self.name()
            self.state = 555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2622:
                self.state = 554
                self.name()


            self.state = 563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 2572)) & ~0x3f) == 0 and ((1 << (_la - 2572)) & 63771674411015) != 0):
                self.state = 561
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2572]:
                    self.state = 557
                    self.resident()
                    pass
                elif token in [2573]:
                    self.state = 558
                    self.nodata()
                    pass
                elif token in [2574]:
                    self.state = 559
                    self.parm()
                    pass
                elif token in [2613, 2615, 2616, 2617]:
                    self.state = 560
                    self.integer()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 565
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResidentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RESIDENT(self):
            return self.getToken(nasm_x86_64_Parser.RESIDENT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_resident

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterResident" ):
                listener.enterResident(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitResident" ):
                listener.exitResident(self)




    def resident(self):

        localctx = nasm_x86_64_Parser.ResidentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_resident)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 566
            self.match(nasm_x86_64_Parser.RESIDENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NodataContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NODATA(self):
            return self.getToken(nasm_x86_64_Parser.NODATA, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_nodata

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNodata" ):
                listener.enterNodata(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNodata" ):
                listener.exitNodata(self)




    def nodata(self):

        localctx = nasm_x86_64_Parser.NodataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_nodata)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 568
            self.match(nasm_x86_64_Parser.NODATA)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParmContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PARM(self):
            return self.getToken(nasm_x86_64_Parser.PARM, 0)

        def EQUAL_1(self):
            return self.getToken(nasm_x86_64_Parser.EQUAL_1, 0)

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_parm

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParm" ):
                listener.enterParm(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParm" ):
                listener.exitParm(self)




    def parm(self):

        localctx = nasm_x86_64_Parser.ParmContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_parm)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 570
            self.match(nasm_x86_64_Parser.PARM)
            self.state = 571
            self.match(nasm_x86_64_Parser.EQUAL_1)
            self.state = 572
            self.integer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SafesehContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SAFESEH(self):
            return self.getToken(nasm_x86_64_Parser.SAFESEH, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_safeseh

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSafeseh" ):
                listener.enterSafeseh(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSafeseh" ):
                listener.exitSafeseh(self)




    def safeseh(self):

        localctx = nasm_x86_64_Parser.SafesehContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_safeseh)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 574
            self.match(nasm_x86_64_Parser.SAFESEH)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OsabiContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OSABI(self):
            return self.getToken(nasm_x86_64_Parser.OSABI, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_osabi

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOsabi" ):
                listener.enterOsabi(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOsabi" ):
                listener.exitOsabi(self)




    def osabi(self):

        localctx = nasm_x86_64_Parser.OsabiContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_osabi)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.match(nasm_x86_64_Parser.OSABI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Times_prefixContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def times(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.TimesContext,0)


        def expression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExpressionContext,0)


        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_times_prefix

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTimes_prefix" ):
                listener.enterTimes_prefix(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTimes_prefix" ):
                listener.exitTimes_prefix(self)




    def times_prefix(self):

        localctx = nasm_x86_64_Parser.Times_prefixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_times_prefix)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 578
            self.times()
            self.state = 581
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 579
                self.expression()
                pass

            elif la_ == 2:
                self.state = 580
                self.integer()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TimesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TIMES(self):
            return self.getToken(nasm_x86_64_Parser.TIMES, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_times

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTimes" ):
                listener.enterTimes(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTimes" ):
                listener.exitTimes(self)




    def times(self):

        localctx = nasm_x86_64_Parser.TimesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_times)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 583
            self.match(nasm_x86_64_Parser.TIMES)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PseudoinstructionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def dx(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.DxContext,0)


        def value(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.ValueContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.ValueContext,i)


        def resx(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ResxContext,0)


        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def incbin(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IncbinContext,0)


        def atom(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.AtomContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.AtomContext,i)


        def equ(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.EquContext,0)


        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def expression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExpressionContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COMMA)
            else:
                return self.getToken(nasm_x86_64_Parser.COMMA, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_pseudoinstruction

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPseudoinstruction" ):
                listener.enterPseudoinstruction(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPseudoinstruction" ):
                listener.exitPseudoinstruction(self)




    def pseudoinstruction(self):

        localctx = nasm_x86_64_Parser.PseudoinstructionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_pseudoinstruction)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 586
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2622:
                self.state = 585
                self.name()


            self.state = 614
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7, 8]:
                self.state = 588
                self.dx()
                self.state = 589
                self.value()
                self.state = 594
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==27:
                    self.state = 590
                    self.match(nasm_x86_64_Parser.COMMA)
                    self.state = 591
                    self.value()
                    self.state = 596
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [9, 10, 11, 12, 13, 14, 15, 16]:
                self.state = 597
                self.resx()
                self.state = 598
                self.integer()
                pass
            elif token in [17]:
                self.state = 600
                self.incbin()
                self.state = 601
                self.atom()
                self.state = 606
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==27:
                    self.state = 602
                    self.match(nasm_x86_64_Parser.COMMA)
                    self.state = 603
                    self.atom()
                    self.state = 608
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [142]:
                self.state = 609
                self.equ()
                self.state = 612
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                if la_ == 1:
                    self.state = 610
                    self.integer()
                    pass

                elif la_ == 2:
                    self.state = 611
                    self.expression()
                    pass


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DxContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DB(self):
            return self.getToken(nasm_x86_64_Parser.DB, 0)

        def DW(self):
            return self.getToken(nasm_x86_64_Parser.DW, 0)

        def DD(self):
            return self.getToken(nasm_x86_64_Parser.DD, 0)

        def DQ(self):
            return self.getToken(nasm_x86_64_Parser.DQ, 0)

        def DT(self):
            return self.getToken(nasm_x86_64_Parser.DT, 0)

        def DO(self):
            return self.getToken(nasm_x86_64_Parser.DO, 0)

        def DY(self):
            return self.getToken(nasm_x86_64_Parser.DY, 0)

        def DZ(self):
            return self.getToken(nasm_x86_64_Parser.DZ, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_dx

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDx" ):
                listener.enterDx(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDx" ):
                listener.exitDx(self)




    def dx(self):

        localctx = nasm_x86_64_Parser.DxContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_dx)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 616
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 510) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Float_numberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FLOAT_NUMBER(self):
            return self.getToken(nasm_x86_64_Parser.FLOAT_NUMBER, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_float_number

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFloat_number" ):
                listener.enterFloat_number(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFloat_number" ):
                listener.exitFloat_number(self)




    def float_number(self):

        localctx = nasm_x86_64_Parser.Float_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_float_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 618
            self.match(nasm_x86_64_Parser.FLOAT_NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QuestionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def QUESTION(self):
            return self.getToken(nasm_x86_64_Parser.QUESTION, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_question

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuestion" ):
                listener.enterQuestion(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuestion" ):
                listener.exitQuestion(self)




    def question(self):

        localctx = nasm_x86_64_Parser.QuestionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_question)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 620
            self.match(nasm_x86_64_Parser.QUESTION)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResxContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RESB(self):
            return self.getToken(nasm_x86_64_Parser.RESB, 0)

        def RESW(self):
            return self.getToken(nasm_x86_64_Parser.RESW, 0)

        def RESD(self):
            return self.getToken(nasm_x86_64_Parser.RESD, 0)

        def RESQ(self):
            return self.getToken(nasm_x86_64_Parser.RESQ, 0)

        def REST(self):
            return self.getToken(nasm_x86_64_Parser.REST, 0)

        def RESO(self):
            return self.getToken(nasm_x86_64_Parser.RESO, 0)

        def RESY(self):
            return self.getToken(nasm_x86_64_Parser.RESY, 0)

        def RESZ(self):
            return self.getToken(nasm_x86_64_Parser.RESZ, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_resx

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterResx" ):
                listener.enterResx(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitResx" ):
                listener.exitResx(self)




    def resx(self):

        localctx = nasm_x86_64_Parser.ResxContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_resx)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 622
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 130560) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IncbinContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INCBIN(self):
            return self.getToken(nasm_x86_64_Parser.INCBIN, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_incbin

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIncbin" ):
                listener.enterIncbin(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIncbin" ):
                listener.exitIncbin(self)




    def incbin(self):

        localctx = nasm_x86_64_Parser.IncbinContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_incbin)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 624
            self.match(nasm_x86_64_Parser.INCBIN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRING(self):
            return self.getToken(nasm_x86_64_Parser.STRING, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_string

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterString" ):
                listener.enterString(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitString" ):
                listener.exitString(self)




    def string(self):

        localctx = nasm_x86_64_Parser.StringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_string)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 626
            self.match(nasm_x86_64_Parser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def atom(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.AtomContext,0)


        def size(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.SizeContext,0)


        def value(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ValueContext,0)


        def list_(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ListContext,0)


        def macro_call(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Macro_callContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_value

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterValue" ):
                listener.enterValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitValue" ):
                listener.exitValue(self)




    def value(self):

        localctx = nasm_x86_64_Parser.ValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_value)
        try:
            self.state = 634
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 628
                self.atom()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 629
                self.size()
                self.state = 630
                self.value()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 632
                self.list_()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 633
                self.macro_call()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtomContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def float_number(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Float_numberContext,0)


        def string(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.StringContext,0)


        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def question(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.QuestionContext,0)


        def expression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExpressionContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_atom

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAtom" ):
                listener.enterAtom(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAtom" ):
                listener.exitAtom(self)




    def atom(self):

        localctx = nasm_x86_64_Parser.AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_atom)
        try:
            self.state = 642
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 636
                self.integer()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 637
                self.float_number()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 638
                self.string()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 639
                self.name()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 640
                self.question()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 641
                self.expression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SizeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BYTE(self):
            return self.getToken(nasm_x86_64_Parser.BYTE, 0)

        def WORD(self):
            return self.getToken(nasm_x86_64_Parser.WORD, 0)

        def DWORD(self):
            return self.getToken(nasm_x86_64_Parser.DWORD, 0)

        def QWORD(self):
            return self.getToken(nasm_x86_64_Parser.QWORD, 0)

        def TWORD(self):
            return self.getToken(nasm_x86_64_Parser.TWORD, 0)

        def OWORD(self):
            return self.getToken(nasm_x86_64_Parser.OWORD, 0)

        def YWORD(self):
            return self.getToken(nasm_x86_64_Parser.YWORD, 0)

        def ZWORD(self):
            return self.getToken(nasm_x86_64_Parser.ZWORD, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_size

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSize" ):
                listener.enterSize(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSize" ):
                listener.exitSize(self)




    def size(self):

        localctx = nasm_x86_64_Parser.SizeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_size)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 644
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 66846720) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def duplist(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.DuplistContext,0)


        def PERCENT(self):
            return self.getToken(nasm_x86_64_Parser.PERCENT, 0)

        def parlist(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ParlistContext,0)


        def size(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.SizeContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterList" ):
                listener.enterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitList" ):
                listener.exitList(self)




    def list_(self):

        localctx = nasm_x86_64_Parser.ListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_list)
        self._la = 0 # Token type
        try:
            self.state = 655
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [29, 53, 54, 60, 61, 62, 63, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 2612, 2613, 2615, 2616, 2617, 2618, 2622]:
                self.enterOuterAlt(localctx, 1)
                self.state = 646
                self.duplist()
                pass
            elif token in [58]:
                self.enterOuterAlt(localctx, 2)
                self.state = 647
                self.match(nasm_x86_64_Parser.PERCENT)
                self.state = 648
                self.parlist()
                pass
            elif token in [18, 19, 20, 21, 22, 23, 24, 25]:
                self.enterOuterAlt(localctx, 3)
                self.state = 649
                self.size()
                self.state = 651
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==58:
                    self.state = 650
                    self.match(nasm_x86_64_Parser.PERCENT)


                self.state = 653
                self.parlist()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DuplistContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExpressionContext,0)


        def DUP(self):
            return self.getToken(nasm_x86_64_Parser.DUP, 0)

        def parlist(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ParlistContext,0)


        def size(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.SizeContext,0)


        def PERCENT(self):
            return self.getToken(nasm_x86_64_Parser.PERCENT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_duplist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDuplist" ):
                listener.enterDuplist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDuplist" ):
                listener.exitDuplist(self)




    def duplist(self):

        localctx = nasm_x86_64_Parser.DuplistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_duplist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 657
            self.expression()
            self.state = 658
            self.match(nasm_x86_64_Parser.DUP)
            self.state = 660
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 66846720) != 0):
                self.state = 659
                self.size()


            self.state = 663
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==58:
                self.state = 662
                self.match(nasm_x86_64_Parser.PERCENT)


            self.state = 665
            self.parlist()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParlistContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEFT_PARENTHESIS(self):
            return self.getToken(nasm_x86_64_Parser.LEFT_PARENTHESIS, 0)

        def value(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.ValueContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.ValueContext,i)


        def RIGHT_PARENTHESIS(self):
            return self.getToken(nasm_x86_64_Parser.RIGHT_PARENTHESIS, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COMMA)
            else:
                return self.getToken(nasm_x86_64_Parser.COMMA, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_parlist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParlist" ):
                listener.enterParlist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParlist" ):
                listener.exitParlist(self)




    def parlist(self):

        localctx = nasm_x86_64_Parser.ParlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_parlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 667
            self.match(nasm_x86_64_Parser.LEFT_PARENTHESIS)
            self.state = 668
            self.value()
            self.state = 673
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==27:
                self.state = 669
                self.match(nasm_x86_64_Parser.COMMA)
                self.state = 670
                self.value()
                self.state = 675
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 676
            self.match(nasm_x86_64_Parser.RIGHT_PARENTHESIS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def unaryOperator(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.UnaryOperatorContext,0)


        def castExpression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.CastExpressionContext,0)


        def LEFT_PARENTHESIS(self):
            return self.getToken(nasm_x86_64_Parser.LEFT_PARENTHESIS, 0)

        def expression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ExpressionContext,0)


        def RIGHT_PARENTHESIS(self):
            return self.getToken(nasm_x86_64_Parser.RIGHT_PARENTHESIS, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_unaryExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnaryExpression" ):
                listener.enterUnaryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnaryExpression" ):
                listener.exitUnaryExpression(self)




    def unaryExpression(self):

        localctx = nasm_x86_64_Parser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_unaryExpression)
        try:
            self.state = 685
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [53, 54, 60, 61]:
                self.enterOuterAlt(localctx, 1)
                self.state = 678
                self.unaryOperator()
                self.state = 679
                self.castExpression()
                pass
            elif token in [29]:
                self.enterOuterAlt(localctx, 2)
                self.state = 681
                self.match(nasm_x86_64_Parser.LEFT_PARENTHESIS)
                self.state = 682
                self.expression()
                self.state = 683
                self.match(nasm_x86_64_Parser.RIGHT_PARENTHESIS)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnaryOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PLUS(self):
            return self.getToken(nasm_x86_64_Parser.PLUS, 0)

        def MINUS(self):
            return self.getToken(nasm_x86_64_Parser.MINUS, 0)

        def BITWISE_NOT(self):
            return self.getToken(nasm_x86_64_Parser.BITWISE_NOT, 0)

        def BOOLEAN_NOT(self):
            return self.getToken(nasm_x86_64_Parser.BOOLEAN_NOT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_unaryOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnaryOperator" ):
                listener.enterUnaryOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnaryOperator" ):
                listener.exitUnaryOperator(self)




    def unaryOperator(self):

        localctx = nasm_x86_64_Parser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 687
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 3485786111584763904) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CastExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def unaryExpression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.UnaryExpressionContext,0)


        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def register(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.RegisterContext,0)


        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def string(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.StringContext,0)


        def float_number(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Float_numberContext,0)


        def DOLLAR(self):
            return self.getToken(nasm_x86_64_Parser.DOLLAR, 0)

        def DOUBLE_DOLLAR(self):
            return self.getToken(nasm_x86_64_Parser.DOUBLE_DOLLAR, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_castExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCastExpression" ):
                listener.enterCastExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCastExpression" ):
                listener.exitCastExpression(self)




    def castExpression(self):

        localctx = nasm_x86_64_Parser.CastExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_castExpression)
        self._la = 0 # Token type
        try:
            self.state = 702
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 689
                self.unaryExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 690
                self.integer()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 691
                self.register()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 695
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 560)) & ~0x3f) == 0 and ((1 << (_la - 560)) & -1) != 0) or ((((_la - 624)) & ~0x3f) == 0 and ((1 << (_la - 624)) & -1) != 0) or ((((_la - 688)) & ~0x3f) == 0 and ((1 << (_la - 688)) & -1) != 0) or ((((_la - 752)) & ~0x3f) == 0 and ((1 << (_la - 752)) & 576460752303423487) != 0):
                    self.state = 692
                    self.register()
                    self.state = 693
                    self.match(nasm_x86_64_Parser.COLON)


                self.state = 697
                self.name()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 698
                self.string()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 699
                self.float_number()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 700
                self.match(nasm_x86_64_Parser.DOLLAR)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 701
                self.match(nasm_x86_64_Parser.DOUBLE_DOLLAR)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MultiplicativeExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def castExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.CastExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.CastExpressionContext,i)


        def MULTIPLICATION(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.MULTIPLICATION)
            else:
                return self.getToken(nasm_x86_64_Parser.MULTIPLICATION, i)

        def UNSIGNED_DIVISION(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.UNSIGNED_DIVISION)
            else:
                return self.getToken(nasm_x86_64_Parser.UNSIGNED_DIVISION, i)

        def SIGNED_DIVISION(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.SIGNED_DIVISION)
            else:
                return self.getToken(nasm_x86_64_Parser.SIGNED_DIVISION, i)

        def PERCENT(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.PERCENT)
            else:
                return self.getToken(nasm_x86_64_Parser.PERCENT, i)

        def SIGNED_MODULE(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.SIGNED_MODULE)
            else:
                return self.getToken(nasm_x86_64_Parser.SIGNED_MODULE, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_multiplicativeExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMultiplicativeExpression" ):
                listener.enterMultiplicativeExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMultiplicativeExpression" ):
                listener.exitMultiplicativeExpression(self)




    def multiplicativeExpression(self):

        localctx = nasm_x86_64_Parser.MultiplicativeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 704
            self.castExpression()
            self.state = 709
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 1116892707587883008) != 0):
                self.state = 705
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1116892707587883008) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 706
                self.castExpression()
                self.state = 711
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AdditiveExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def multiplicativeExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.MultiplicativeExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.MultiplicativeExpressionContext,i)


        def PLUS(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.PLUS)
            else:
                return self.getToken(nasm_x86_64_Parser.PLUS, i)

        def MINUS(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.MINUS)
            else:
                return self.getToken(nasm_x86_64_Parser.MINUS, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_additiveExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAdditiveExpression" ):
                listener.enterAdditiveExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAdditiveExpression" ):
                listener.exitAdditiveExpression(self)




    def additiveExpression(self):

        localctx = nasm_x86_64_Parser.AdditiveExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            self.multiplicativeExpression()
            self.state = 717
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==53 or _la==54:
                self.state = 713
                _la = self._input.LA(1)
                if not(_la==53 or _la==54):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 714
                self.multiplicativeExpression()
                self.state = 719
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShiftExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def additiveExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.AdditiveExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.AdditiveExpressionContext,i)


        def LEFT_SHIFT(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.LEFT_SHIFT)
            else:
                return self.getToken(nasm_x86_64_Parser.LEFT_SHIFT, i)

        def RIGHT_SHIFT(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.RIGHT_SHIFT)
            else:
                return self.getToken(nasm_x86_64_Parser.RIGHT_SHIFT, i)

        def LEFT_SHIFT_COMPLETENESS(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.LEFT_SHIFT_COMPLETENESS)
            else:
                return self.getToken(nasm_x86_64_Parser.LEFT_SHIFT_COMPLETENESS, i)

        def RIGHT_SHIFT_COMPLETENESS(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.RIGHT_SHIFT_COMPLETENESS)
            else:
                return self.getToken(nasm_x86_64_Parser.RIGHT_SHIFT_COMPLETENESS, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_shiftExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShiftExpression" ):
                listener.enterShiftExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShiftExpression" ):
                listener.exitShiftExpression(self)




    def shiftExpression(self):

        localctx = nasm_x86_64_Parser.ShiftExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_shiftExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 720
            self.additiveExpression()
            self.state = 725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8444249301319680) != 0):
                self.state = 721
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 8444249301319680) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 722
                self.additiveExpression()
                self.state = 727
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def shiftExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.ShiftExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.ShiftExpressionContext,i)


        def LESS_THAN(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.LESS_THAN)
            else:
                return self.getToken(nasm_x86_64_Parser.LESS_THAN, i)

        def LESS_THAN_EQUAL(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.LESS_THAN_EQUAL)
            else:
                return self.getToken(nasm_x86_64_Parser.LESS_THAN_EQUAL, i)

        def GREATER_THAN(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.GREATER_THAN)
            else:
                return self.getToken(nasm_x86_64_Parser.GREATER_THAN, i)

        def SIGNED_COMPARISON(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.SIGNED_COMPARISON)
            else:
                return self.getToken(nasm_x86_64_Parser.SIGNED_COMPARISON, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_relationalExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRelationalExpression" ):
                listener.enterRelationalExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRelationalExpression" ):
                listener.exitRelationalExpression(self)




    def relationalExpression(self):

        localctx = nasm_x86_64_Parser.RelationalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_relationalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.shiftExpression()
            self.state = 733
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 50577534877696) != 0):
                self.state = 729
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 50577534877696) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 730
                self.shiftExpression()
                self.state = 735
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EqualityExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def relationalExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.RelationalExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.RelationalExpressionContext,i)


        def EQUAL_1(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.EQUAL_1)
            else:
                return self.getToken(nasm_x86_64_Parser.EQUAL_1, i)

        def EQUAL_2(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.EQUAL_2)
            else:
                return self.getToken(nasm_x86_64_Parser.EQUAL_2, i)

        def NOT_EQUAL_1(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.NOT_EQUAL_1)
            else:
                return self.getToken(nasm_x86_64_Parser.NOT_EQUAL_1, i)

        def NOT_EQUAL_2(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.NOT_EQUAL_2)
            else:
                return self.getToken(nasm_x86_64_Parser.NOT_EQUAL_2, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_equalityExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEqualityExpression" ):
                listener.enterEqualityExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEqualityExpression" ):
                listener.exitEqualityExpression(self)




    def equalityExpression(self):

        localctx = nasm_x86_64_Parser.EqualityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_equalityExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 736
            self.relationalExpression()
            self.state = 741
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2061584302080) != 0):
                self.state = 737
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 2061584302080) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 738
                self.relationalExpression()
                self.state = 743
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def equalityExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.EqualityExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.EqualityExpressionContext,i)


        def BITWISE_AND(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.BITWISE_AND)
            else:
                return self.getToken(nasm_x86_64_Parser.BITWISE_AND, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_andExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAndExpression" ):
                listener.enterAndExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAndExpression" ):
                listener.exitAndExpression(self)




    def andExpression(self):

        localctx = nasm_x86_64_Parser.AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_andExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.equalityExpression()
            self.state = 749
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==48:
                self.state = 745
                self.match(nasm_x86_64_Parser.BITWISE_AND)
                self.state = 746
                self.equalityExpression()
                self.state = 751
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def andExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.AndExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.AndExpressionContext,i)


        def BITWISE_XOR(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.BITWISE_XOR)
            else:
                return self.getToken(nasm_x86_64_Parser.BITWISE_XOR, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_exclusiveOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExclusiveOrExpression" ):
                listener.enterExclusiveOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExclusiveOrExpression" ):
                listener.exitExclusiveOrExpression(self)




    def exclusiveOrExpression(self):

        localctx = nasm_x86_64_Parser.ExclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_exclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 752
            self.andExpression()
            self.state = 757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==47:
                self.state = 753
                self.match(nasm_x86_64_Parser.BITWISE_XOR)
                self.state = 754
                self.andExpression()
                self.state = 759
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def exclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.ExclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.ExclusiveOrExpressionContext,i)


        def BITWISE_OR(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.BITWISE_OR)
            else:
                return self.getToken(nasm_x86_64_Parser.BITWISE_OR, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_inclusiveOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInclusiveOrExpression" ):
                listener.enterInclusiveOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInclusiveOrExpression" ):
                listener.exitInclusiveOrExpression(self)




    def inclusiveOrExpression(self):

        localctx = nasm_x86_64_Parser.InclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_inclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 760
            self.exclusiveOrExpression()
            self.state = 765
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==46:
                self.state = 761
                self.match(nasm_x86_64_Parser.BITWISE_OR)
                self.state = 762
                self.exclusiveOrExpression()
                self.state = 767
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanAndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def inclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.InclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.InclusiveOrExpressionContext,i)


        def BOOLEAN_AND(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.BOOLEAN_AND)
            else:
                return self.getToken(nasm_x86_64_Parser.BOOLEAN_AND, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_booleanAndExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBooleanAndExpression" ):
                listener.enterBooleanAndExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBooleanAndExpression" ):
                listener.exitBooleanAndExpression(self)




    def booleanAndExpression(self):

        localctx = nasm_x86_64_Parser.BooleanAndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_booleanAndExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 768
            self.inclusiveOrExpression()
            self.state = 773
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==36:
                self.state = 769
                self.match(nasm_x86_64_Parser.BOOLEAN_AND)
                self.state = 770
                self.inclusiveOrExpression()
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def booleanAndExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.BooleanAndExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.BooleanAndExpressionContext,i)


        def BOOLEAN_OR(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.BOOLEAN_OR)
            else:
                return self.getToken(nasm_x86_64_Parser.BOOLEAN_OR, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_booleanOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBooleanOrExpression" ):
                listener.enterBooleanOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBooleanOrExpression" ):
                listener.exitBooleanOrExpression(self)




    def booleanOrExpression(self):

        localctx = nasm_x86_64_Parser.BooleanOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_booleanOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 776
            self.booleanAndExpression()
            self.state = 781
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==34:
                self.state = 777
                self.match(nasm_x86_64_Parser.BOOLEAN_OR)
                self.state = 778
                self.booleanAndExpression()
                self.state = 783
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConditionalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def booleanOrExpression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.BooleanOrExpressionContext,0)


        def QUESTION(self):
            return self.getToken(nasm_x86_64_Parser.QUESTION, 0)

        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def conditionalExpression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ConditionalExpressionContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_conditionalExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConditionalExpression" ):
                listener.enterConditionalExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConditionalExpression" ):
                listener.exitConditionalExpression(self)




    def conditionalExpression(self):

        localctx = nasm_x86_64_Parser.ConditionalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_conditionalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 784
            self.booleanOrExpression()
            self.state = 790
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==28:
                self.state = 785
                self.match(nasm_x86_64_Parser.QUESTION)
                self.state = 786
                self.integer()
                self.state = 787
                self.match(nasm_x86_64_Parser.COLON)
                self.state = 788
                self.conditionalExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def conditionalExpression(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.ConditionalExpressionContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpression" ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpression" ):
                listener.exitExpression(self)




    def expression(self):

        localctx = nasm_x86_64_Parser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 792
            self.conditionalExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EquContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQU(self):
            return self.getToken(nasm_x86_64_Parser.EQU, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_equ

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEqu" ):
                listener.enterEqu(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEqu" ):
                listener.exitEqu(self)




    def equ(self):

        localctx = nasm_x86_64_Parser.EquContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_equ)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 794
            self.match(nasm_x86_64_Parser.EQU)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InstructionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def opcode(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.OpcodeContext,0)


        def operand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.OperandContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.OperandContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COMMA)
            else:
                return self.getToken(nasm_x86_64_Parser.COMMA, i)

        def macro_call(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Macro_callContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_instruction

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInstruction" ):
                listener.enterInstruction(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInstruction" ):
                listener.exitInstruction(self)




    def instruction(self):

        localctx = nasm_x86_64_Parser.InstructionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_instruction)
        self._la = 0 # Token type
        try:
            self.state = 808
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, 2506, 2507, 2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521]:
                self.enterOuterAlt(localctx, 1)
                self.state = 796
                self.opcode()
                self.state = 798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -1125899904091422720) != 0) or ((((_la - 560)) & ~0x3f) == 0 and ((1 << (_la - 560)) & -1) != 0) or ((((_la - 624)) & ~0x3f) == 0 and ((1 << (_la - 624)) & -1) != 0) or ((((_la - 688)) & ~0x3f) == 0 and ((1 << (_la - 688)) & -1) != 0) or ((((_la - 752)) & ~0x3f) == 0 and ((1 << (_la - 752)) & 576460752303423487) != 0) or ((((_la - 2610)) & ~0x3f) == 0 and ((1 << (_la - 2610)) & 4589) != 0):
                    self.state = 797
                    self.operand()


                self.state = 804
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==27:
                    self.state = 800
                    self.match(nasm_x86_64_Parser.COMMA)
                    self.state = 801
                    self.operand()
                    self.state = 806
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [2622]:
                self.enterOuterAlt(localctx, 2)
                self.state = 807
                self.macro_call()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OpcodeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AAA(self):
            return self.getToken(nasm_x86_64_Parser.AAA, 0)

        def AAD(self):
            return self.getToken(nasm_x86_64_Parser.AAD, 0)

        def AAM(self):
            return self.getToken(nasm_x86_64_Parser.AAM, 0)

        def AAS(self):
            return self.getToken(nasm_x86_64_Parser.AAS, 0)

        def ADC(self):
            return self.getToken(nasm_x86_64_Parser.ADC, 0)

        def ADD(self):
            return self.getToken(nasm_x86_64_Parser.ADD, 0)

        def AND(self):
            return self.getToken(nasm_x86_64_Parser.AND, 0)

        def ARPL(self):
            return self.getToken(nasm_x86_64_Parser.ARPL, 0)

        def BB0_RESET(self):
            return self.getToken(nasm_x86_64_Parser.BB0_RESET, 0)

        def BB1_RESET(self):
            return self.getToken(nasm_x86_64_Parser.BB1_RESET, 0)

        def BOUND(self):
            return self.getToken(nasm_x86_64_Parser.BOUND, 0)

        def BSF(self):
            return self.getToken(nasm_x86_64_Parser.BSF, 0)

        def BSR(self):
            return self.getToken(nasm_x86_64_Parser.BSR, 0)

        def BSWAP(self):
            return self.getToken(nasm_x86_64_Parser.BSWAP, 0)

        def BT(self):
            return self.getToken(nasm_x86_64_Parser.BT, 0)

        def BTC(self):
            return self.getToken(nasm_x86_64_Parser.BTC, 0)

        def BTR(self):
            return self.getToken(nasm_x86_64_Parser.BTR, 0)

        def BTS(self):
            return self.getToken(nasm_x86_64_Parser.BTS, 0)

        def CALL(self):
            return self.getToken(nasm_x86_64_Parser.CALL, 0)

        def CBW(self):
            return self.getToken(nasm_x86_64_Parser.CBW, 0)

        def CDQ(self):
            return self.getToken(nasm_x86_64_Parser.CDQ, 0)

        def CDQE(self):
            return self.getToken(nasm_x86_64_Parser.CDQE, 0)

        def CLC(self):
            return self.getToken(nasm_x86_64_Parser.CLC, 0)

        def CLD(self):
            return self.getToken(nasm_x86_64_Parser.CLD, 0)

        def CLI(self):
            return self.getToken(nasm_x86_64_Parser.CLI, 0)

        def CLTS(self):
            return self.getToken(nasm_x86_64_Parser.CLTS, 0)

        def CMC(self):
            return self.getToken(nasm_x86_64_Parser.CMC, 0)

        def CMOVA(self):
            return self.getToken(nasm_x86_64_Parser.CMOVA, 0)

        def CMOVAE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVAE, 0)

        def CMOVB(self):
            return self.getToken(nasm_x86_64_Parser.CMOVB, 0)

        def CMOVBE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVBE, 0)

        def CMOVC(self):
            return self.getToken(nasm_x86_64_Parser.CMOVC, 0)

        def CMOVE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVE, 0)

        def CMOVG(self):
            return self.getToken(nasm_x86_64_Parser.CMOVG, 0)

        def CMOVGE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVGE, 0)

        def CMOVL(self):
            return self.getToken(nasm_x86_64_Parser.CMOVL, 0)

        def CMOVLE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVLE, 0)

        def CMOVNA(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNA, 0)

        def CMOVNAE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNAE, 0)

        def CMOVNB(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNB, 0)

        def CMOVNBE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNBE, 0)

        def CMOVNC(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNC, 0)

        def CMOVNE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNE, 0)

        def CMOVNG(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNG, 0)

        def CMOVNGE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNGE, 0)

        def CMOVNL(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNL, 0)

        def CMOVNO(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNO, 0)

        def CMOVNP(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNP, 0)

        def CMOVNS(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNS, 0)

        def CMOVNZ(self):
            return self.getToken(nasm_x86_64_Parser.CMOVNZ, 0)

        def CMOVO(self):
            return self.getToken(nasm_x86_64_Parser.CMOVO, 0)

        def CMOVP(self):
            return self.getToken(nasm_x86_64_Parser.CMOVP, 0)

        def CMOVPE(self):
            return self.getToken(nasm_x86_64_Parser.CMOVPE, 0)

        def CMOVPO(self):
            return self.getToken(nasm_x86_64_Parser.CMOVPO, 0)

        def CMOVS(self):
            return self.getToken(nasm_x86_64_Parser.CMOVS, 0)

        def CMOVZ(self):
            return self.getToken(nasm_x86_64_Parser.CMOVZ, 0)

        def CMP(self):
            return self.getToken(nasm_x86_64_Parser.CMP, 0)

        def CMPSB(self):
            return self.getToken(nasm_x86_64_Parser.CMPSB, 0)

        def CMPSD(self):
            return self.getToken(nasm_x86_64_Parser.CMPSD, 0)

        def CMPSQ(self):
            return self.getToken(nasm_x86_64_Parser.CMPSQ, 0)

        def CMPSW(self):
            return self.getToken(nasm_x86_64_Parser.CMPSW, 0)

        def CMPXCHG(self):
            return self.getToken(nasm_x86_64_Parser.CMPXCHG, 0)

        def CMPXCHG16B(self):
            return self.getToken(nasm_x86_64_Parser.CMPXCHG16B, 0)

        def CMPXCHG486(self):
            return self.getToken(nasm_x86_64_Parser.CMPXCHG486, 0)

        def CMPXCHG8B(self):
            return self.getToken(nasm_x86_64_Parser.CMPXCHG8B, 0)

        def CPU_READ(self):
            return self.getToken(nasm_x86_64_Parser.CPU_READ, 0)

        def CPU_WRITE(self):
            return self.getToken(nasm_x86_64_Parser.CPU_WRITE, 0)

        def CPUID(self):
            return self.getToken(nasm_x86_64_Parser.CPUID, 0)

        def CQO(self):
            return self.getToken(nasm_x86_64_Parser.CQO, 0)

        def CWD(self):
            return self.getToken(nasm_x86_64_Parser.CWD, 0)

        def CWDE(self):
            return self.getToken(nasm_x86_64_Parser.CWDE, 0)

        def DAA(self):
            return self.getToken(nasm_x86_64_Parser.DAA, 0)

        def DAS(self):
            return self.getToken(nasm_x86_64_Parser.DAS, 0)

        def DEC(self):
            return self.getToken(nasm_x86_64_Parser.DEC, 0)

        def DIV(self):
            return self.getToken(nasm_x86_64_Parser.DIV, 0)

        def DMINT(self):
            return self.getToken(nasm_x86_64_Parser.DMINT, 0)

        def EMMS(self):
            return self.getToken(nasm_x86_64_Parser.EMMS, 0)

        def ENTER(self):
            return self.getToken(nasm_x86_64_Parser.ENTER, 0)

        def EQU(self):
            return self.getToken(nasm_x86_64_Parser.EQU, 0)

        def F2XM1(self):
            return self.getToken(nasm_x86_64_Parser.F2XM1, 0)

        def FABS(self):
            return self.getToken(nasm_x86_64_Parser.FABS, 0)

        def FADD(self):
            return self.getToken(nasm_x86_64_Parser.FADD, 0)

        def FADDP(self):
            return self.getToken(nasm_x86_64_Parser.FADDP, 0)

        def FBLD(self):
            return self.getToken(nasm_x86_64_Parser.FBLD, 0)

        def FBSTP(self):
            return self.getToken(nasm_x86_64_Parser.FBSTP, 0)

        def FCHS(self):
            return self.getToken(nasm_x86_64_Parser.FCHS, 0)

        def FCLEX(self):
            return self.getToken(nasm_x86_64_Parser.FCLEX, 0)

        def FCMOVB(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVB, 0)

        def FCMOVBE(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVBE, 0)

        def FCMOVE(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVE, 0)

        def FCMOVNB(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVNB, 0)

        def FCMOVNBE(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVNBE, 0)

        def FCMOVNE(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVNE, 0)

        def FCMOVNU(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVNU, 0)

        def FCMOVU(self):
            return self.getToken(nasm_x86_64_Parser.FCMOVU, 0)

        def FCOM(self):
            return self.getToken(nasm_x86_64_Parser.FCOM, 0)

        def FCOMI(self):
            return self.getToken(nasm_x86_64_Parser.FCOMI, 0)

        def FCOMIP(self):
            return self.getToken(nasm_x86_64_Parser.FCOMIP, 0)

        def FCOMP(self):
            return self.getToken(nasm_x86_64_Parser.FCOMP, 0)

        def FCOMPP(self):
            return self.getToken(nasm_x86_64_Parser.FCOMPP, 0)

        def FCOS(self):
            return self.getToken(nasm_x86_64_Parser.FCOS, 0)

        def FDECSTP(self):
            return self.getToken(nasm_x86_64_Parser.FDECSTP, 0)

        def FDISI(self):
            return self.getToken(nasm_x86_64_Parser.FDISI, 0)

        def FDIV(self):
            return self.getToken(nasm_x86_64_Parser.FDIV, 0)

        def FDIVP(self):
            return self.getToken(nasm_x86_64_Parser.FDIVP, 0)

        def FDIVR(self):
            return self.getToken(nasm_x86_64_Parser.FDIVR, 0)

        def FDIVRP(self):
            return self.getToken(nasm_x86_64_Parser.FDIVRP, 0)

        def FEMMS(self):
            return self.getToken(nasm_x86_64_Parser.FEMMS, 0)

        def FENI(self):
            return self.getToken(nasm_x86_64_Parser.FENI, 0)

        def FFREE(self):
            return self.getToken(nasm_x86_64_Parser.FFREE, 0)

        def FFREEP(self):
            return self.getToken(nasm_x86_64_Parser.FFREEP, 0)

        def FIADD(self):
            return self.getToken(nasm_x86_64_Parser.FIADD, 0)

        def FICOM(self):
            return self.getToken(nasm_x86_64_Parser.FICOM, 0)

        def FICOMP(self):
            return self.getToken(nasm_x86_64_Parser.FICOMP, 0)

        def FIDIV(self):
            return self.getToken(nasm_x86_64_Parser.FIDIV, 0)

        def FIDIVR(self):
            return self.getToken(nasm_x86_64_Parser.FIDIVR, 0)

        def FILD(self):
            return self.getToken(nasm_x86_64_Parser.FILD, 0)

        def FIMUL(self):
            return self.getToken(nasm_x86_64_Parser.FIMUL, 0)

        def FINCSTP(self):
            return self.getToken(nasm_x86_64_Parser.FINCSTP, 0)

        def FINIT(self):
            return self.getToken(nasm_x86_64_Parser.FINIT, 0)

        def FIST(self):
            return self.getToken(nasm_x86_64_Parser.FIST, 0)

        def FISTP(self):
            return self.getToken(nasm_x86_64_Parser.FISTP, 0)

        def FISTTP(self):
            return self.getToken(nasm_x86_64_Parser.FISTTP, 0)

        def FISUB(self):
            return self.getToken(nasm_x86_64_Parser.FISUB, 0)

        def FISUBR(self):
            return self.getToken(nasm_x86_64_Parser.FISUBR, 0)

        def FLD(self):
            return self.getToken(nasm_x86_64_Parser.FLD, 0)

        def FLD1(self):
            return self.getToken(nasm_x86_64_Parser.FLD1, 0)

        def FLDCW(self):
            return self.getToken(nasm_x86_64_Parser.FLDCW, 0)

        def FLDENV(self):
            return self.getToken(nasm_x86_64_Parser.FLDENV, 0)

        def FLDL2E(self):
            return self.getToken(nasm_x86_64_Parser.FLDL2E, 0)

        def FLDL2T(self):
            return self.getToken(nasm_x86_64_Parser.FLDL2T, 0)

        def FLDLG2(self):
            return self.getToken(nasm_x86_64_Parser.FLDLG2, 0)

        def FLDLN2(self):
            return self.getToken(nasm_x86_64_Parser.FLDLN2, 0)

        def FLDPI(self):
            return self.getToken(nasm_x86_64_Parser.FLDPI, 0)

        def FLDZ(self):
            return self.getToken(nasm_x86_64_Parser.FLDZ, 0)

        def FMUL(self):
            return self.getToken(nasm_x86_64_Parser.FMUL, 0)

        def FMULP(self):
            return self.getToken(nasm_x86_64_Parser.FMULP, 0)

        def FNCLEX(self):
            return self.getToken(nasm_x86_64_Parser.FNCLEX, 0)

        def FNDISI(self):
            return self.getToken(nasm_x86_64_Parser.FNDISI, 0)

        def FNENI(self):
            return self.getToken(nasm_x86_64_Parser.FNENI, 0)

        def FNINIT(self):
            return self.getToken(nasm_x86_64_Parser.FNINIT, 0)

        def FNOP(self):
            return self.getToken(nasm_x86_64_Parser.FNOP, 0)

        def FNSAVE(self):
            return self.getToken(nasm_x86_64_Parser.FNSAVE, 0)

        def FNSTCW(self):
            return self.getToken(nasm_x86_64_Parser.FNSTCW, 0)

        def FNSTENV(self):
            return self.getToken(nasm_x86_64_Parser.FNSTENV, 0)

        def FNSTSW(self):
            return self.getToken(nasm_x86_64_Parser.FNSTSW, 0)

        def FPATAN(self):
            return self.getToken(nasm_x86_64_Parser.FPATAN, 0)

        def FPREM(self):
            return self.getToken(nasm_x86_64_Parser.FPREM, 0)

        def FPREM1(self):
            return self.getToken(nasm_x86_64_Parser.FPREM1, 0)

        def FPTAN(self):
            return self.getToken(nasm_x86_64_Parser.FPTAN, 0)

        def FRNDINT(self):
            return self.getToken(nasm_x86_64_Parser.FRNDINT, 0)

        def FRSTOR(self):
            return self.getToken(nasm_x86_64_Parser.FRSTOR, 0)

        def FSAVE(self):
            return self.getToken(nasm_x86_64_Parser.FSAVE, 0)

        def FSCALE(self):
            return self.getToken(nasm_x86_64_Parser.FSCALE, 0)

        def FSETPM(self):
            return self.getToken(nasm_x86_64_Parser.FSETPM, 0)

        def FSIN(self):
            return self.getToken(nasm_x86_64_Parser.FSIN, 0)

        def FSINCOS(self):
            return self.getToken(nasm_x86_64_Parser.FSINCOS, 0)

        def FSQRT(self):
            return self.getToken(nasm_x86_64_Parser.FSQRT, 0)

        def FST(self):
            return self.getToken(nasm_x86_64_Parser.FST, 0)

        def FSTCW(self):
            return self.getToken(nasm_x86_64_Parser.FSTCW, 0)

        def FSTENV(self):
            return self.getToken(nasm_x86_64_Parser.FSTENV, 0)

        def FSTP(self):
            return self.getToken(nasm_x86_64_Parser.FSTP, 0)

        def FSTSW(self):
            return self.getToken(nasm_x86_64_Parser.FSTSW, 0)

        def FSUB(self):
            return self.getToken(nasm_x86_64_Parser.FSUB, 0)

        def FSUBP(self):
            return self.getToken(nasm_x86_64_Parser.FSUBP, 0)

        def FSUBR(self):
            return self.getToken(nasm_x86_64_Parser.FSUBR, 0)

        def FSUBRP(self):
            return self.getToken(nasm_x86_64_Parser.FSUBRP, 0)

        def FTST(self):
            return self.getToken(nasm_x86_64_Parser.FTST, 0)

        def FUCOM(self):
            return self.getToken(nasm_x86_64_Parser.FUCOM, 0)

        def FUCOMI(self):
            return self.getToken(nasm_x86_64_Parser.FUCOMI, 0)

        def FUCOMIP(self):
            return self.getToken(nasm_x86_64_Parser.FUCOMIP, 0)

        def FUCOMP(self):
            return self.getToken(nasm_x86_64_Parser.FUCOMP, 0)

        def FUCOMPP(self):
            return self.getToken(nasm_x86_64_Parser.FUCOMPP, 0)

        def FWAIT(self):
            return self.getToken(nasm_x86_64_Parser.FWAIT, 0)

        def FXAM(self):
            return self.getToken(nasm_x86_64_Parser.FXAM, 0)

        def FXCH(self):
            return self.getToken(nasm_x86_64_Parser.FXCH, 0)

        def FXTRACT(self):
            return self.getToken(nasm_x86_64_Parser.FXTRACT, 0)

        def FYL2X(self):
            return self.getToken(nasm_x86_64_Parser.FYL2X, 0)

        def FYL2XP1(self):
            return self.getToken(nasm_x86_64_Parser.FYL2XP1, 0)

        def HLT(self):
            return self.getToken(nasm_x86_64_Parser.HLT, 0)

        def IBTS(self):
            return self.getToken(nasm_x86_64_Parser.IBTS, 0)

        def ICEBP(self):
            return self.getToken(nasm_x86_64_Parser.ICEBP, 0)

        def IDIV(self):
            return self.getToken(nasm_x86_64_Parser.IDIV, 0)

        def IMUL(self):
            return self.getToken(nasm_x86_64_Parser.IMUL, 0)

        def IN(self):
            return self.getToken(nasm_x86_64_Parser.IN, 0)

        def INC(self):
            return self.getToken(nasm_x86_64_Parser.INC, 0)

        def INSB(self):
            return self.getToken(nasm_x86_64_Parser.INSB, 0)

        def INSD(self):
            return self.getToken(nasm_x86_64_Parser.INSD, 0)

        def INSW(self):
            return self.getToken(nasm_x86_64_Parser.INSW, 0)

        def INT(self):
            return self.getToken(nasm_x86_64_Parser.INT, 0)

        def INT01(self):
            return self.getToken(nasm_x86_64_Parser.INT01, 0)

        def INT03(self):
            return self.getToken(nasm_x86_64_Parser.INT03, 0)

        def INT1(self):
            return self.getToken(nasm_x86_64_Parser.INT1, 0)

        def INT3(self):
            return self.getToken(nasm_x86_64_Parser.INT3, 0)

        def INTO(self):
            return self.getToken(nasm_x86_64_Parser.INTO, 0)

        def INVD(self):
            return self.getToken(nasm_x86_64_Parser.INVD, 0)

        def INVLPG(self):
            return self.getToken(nasm_x86_64_Parser.INVLPG, 0)

        def INVLPGA(self):
            return self.getToken(nasm_x86_64_Parser.INVLPGA, 0)

        def INVPCID(self):
            return self.getToken(nasm_x86_64_Parser.INVPCID, 0)

        def IRET(self):
            return self.getToken(nasm_x86_64_Parser.IRET, 0)

        def IRETD(self):
            return self.getToken(nasm_x86_64_Parser.IRETD, 0)

        def IRETQ(self):
            return self.getToken(nasm_x86_64_Parser.IRETQ, 0)

        def IRETW(self):
            return self.getToken(nasm_x86_64_Parser.IRETW, 0)

        def JA(self):
            return self.getToken(nasm_x86_64_Parser.JA, 0)

        def JAE(self):
            return self.getToken(nasm_x86_64_Parser.JAE, 0)

        def JB(self):
            return self.getToken(nasm_x86_64_Parser.JB, 0)

        def JBE(self):
            return self.getToken(nasm_x86_64_Parser.JBE, 0)

        def JC(self):
            return self.getToken(nasm_x86_64_Parser.JC, 0)

        def JCXZ(self):
            return self.getToken(nasm_x86_64_Parser.JCXZ, 0)

        def JE(self):
            return self.getToken(nasm_x86_64_Parser.JE, 0)

        def JECXZ(self):
            return self.getToken(nasm_x86_64_Parser.JECXZ, 0)

        def JG(self):
            return self.getToken(nasm_x86_64_Parser.JG, 0)

        def JGE(self):
            return self.getToken(nasm_x86_64_Parser.JGE, 0)

        def JL(self):
            return self.getToken(nasm_x86_64_Parser.JL, 0)

        def JLE(self):
            return self.getToken(nasm_x86_64_Parser.JLE, 0)

        def JMP(self):
            return self.getToken(nasm_x86_64_Parser.JMP, 0)

        def JMPE(self):
            return self.getToken(nasm_x86_64_Parser.JMPE, 0)

        def JNA(self):
            return self.getToken(nasm_x86_64_Parser.JNA, 0)

        def JNAE(self):
            return self.getToken(nasm_x86_64_Parser.JNAE, 0)

        def JNB(self):
            return self.getToken(nasm_x86_64_Parser.JNB, 0)

        def JNBE(self):
            return self.getToken(nasm_x86_64_Parser.JNBE, 0)

        def JNC(self):
            return self.getToken(nasm_x86_64_Parser.JNC, 0)

        def JNE(self):
            return self.getToken(nasm_x86_64_Parser.JNE, 0)

        def JNG(self):
            return self.getToken(nasm_x86_64_Parser.JNG, 0)

        def JNGE(self):
            return self.getToken(nasm_x86_64_Parser.JNGE, 0)

        def JNL(self):
            return self.getToken(nasm_x86_64_Parser.JNL, 0)

        def JNLE(self):
            return self.getToken(nasm_x86_64_Parser.JNLE, 0)

        def JNO(self):
            return self.getToken(nasm_x86_64_Parser.JNO, 0)

        def JNP(self):
            return self.getToken(nasm_x86_64_Parser.JNP, 0)

        def JNS(self):
            return self.getToken(nasm_x86_64_Parser.JNS, 0)

        def JNZ(self):
            return self.getToken(nasm_x86_64_Parser.JNZ, 0)

        def JO(self):
            return self.getToken(nasm_x86_64_Parser.JO, 0)

        def JP(self):
            return self.getToken(nasm_x86_64_Parser.JP, 0)

        def JPE(self):
            return self.getToken(nasm_x86_64_Parser.JPE, 0)

        def JPO(self):
            return self.getToken(nasm_x86_64_Parser.JPO, 0)

        def JRCXZ(self):
            return self.getToken(nasm_x86_64_Parser.JRCXZ, 0)

        def JS(self):
            return self.getToken(nasm_x86_64_Parser.JS, 0)

        def JZ(self):
            return self.getToken(nasm_x86_64_Parser.JZ, 0)

        def LAHF(self):
            return self.getToken(nasm_x86_64_Parser.LAHF, 0)

        def LAR(self):
            return self.getToken(nasm_x86_64_Parser.LAR, 0)

        def LDS(self):
            return self.getToken(nasm_x86_64_Parser.LDS, 0)

        def LEA(self):
            return self.getToken(nasm_x86_64_Parser.LEA, 0)

        def LEAVE(self):
            return self.getToken(nasm_x86_64_Parser.LEAVE, 0)

        def LES(self):
            return self.getToken(nasm_x86_64_Parser.LES, 0)

        def LFENCE(self):
            return self.getToken(nasm_x86_64_Parser.LFENCE, 0)

        def LFS(self):
            return self.getToken(nasm_x86_64_Parser.LFS, 0)

        def LGDT(self):
            return self.getToken(nasm_x86_64_Parser.LGDT, 0)

        def LGS(self):
            return self.getToken(nasm_x86_64_Parser.LGS, 0)

        def LIDT(self):
            return self.getToken(nasm_x86_64_Parser.LIDT, 0)

        def LLDT(self):
            return self.getToken(nasm_x86_64_Parser.LLDT, 0)

        def LMSW(self):
            return self.getToken(nasm_x86_64_Parser.LMSW, 0)

        def LOADALL(self):
            return self.getToken(nasm_x86_64_Parser.LOADALL, 0)

        def LOADALL286(self):
            return self.getToken(nasm_x86_64_Parser.LOADALL286, 0)

        def LODSB(self):
            return self.getToken(nasm_x86_64_Parser.LODSB, 0)

        def LODSD(self):
            return self.getToken(nasm_x86_64_Parser.LODSD, 0)

        def LODSQ(self):
            return self.getToken(nasm_x86_64_Parser.LODSQ, 0)

        def LODSW(self):
            return self.getToken(nasm_x86_64_Parser.LODSW, 0)

        def LOOP(self):
            return self.getToken(nasm_x86_64_Parser.LOOP, 0)

        def LOOPE(self):
            return self.getToken(nasm_x86_64_Parser.LOOPE, 0)

        def LOOPNE(self):
            return self.getToken(nasm_x86_64_Parser.LOOPNE, 0)

        def LOOPNZ(self):
            return self.getToken(nasm_x86_64_Parser.LOOPNZ, 0)

        def LOOPZ(self):
            return self.getToken(nasm_x86_64_Parser.LOOPZ, 0)

        def LSL(self):
            return self.getToken(nasm_x86_64_Parser.LSL, 0)

        def LSS(self):
            return self.getToken(nasm_x86_64_Parser.LSS, 0)

        def LTR(self):
            return self.getToken(nasm_x86_64_Parser.LTR, 0)

        def MFENCE(self):
            return self.getToken(nasm_x86_64_Parser.MFENCE, 0)

        def MONITOR(self):
            return self.getToken(nasm_x86_64_Parser.MONITOR, 0)

        def MONITORX(self):
            return self.getToken(nasm_x86_64_Parser.MONITORX, 0)

        def MOV(self):
            return self.getToken(nasm_x86_64_Parser.MOV, 0)

        def MOVD(self):
            return self.getToken(nasm_x86_64_Parser.MOVD, 0)

        def MOVQ(self):
            return self.getToken(nasm_x86_64_Parser.MOVQ, 0)

        def MOVSB(self):
            return self.getToken(nasm_x86_64_Parser.MOVSB, 0)

        def MOVSD(self):
            return self.getToken(nasm_x86_64_Parser.MOVSD, 0)

        def MOVSQ(self):
            return self.getToken(nasm_x86_64_Parser.MOVSQ, 0)

        def MOVSW(self):
            return self.getToken(nasm_x86_64_Parser.MOVSW, 0)

        def MOVSX(self):
            return self.getToken(nasm_x86_64_Parser.MOVSX, 0)

        def MOVSXD(self):
            return self.getToken(nasm_x86_64_Parser.MOVSXD, 0)

        def MOVZX(self):
            return self.getToken(nasm_x86_64_Parser.MOVZX, 0)

        def MUL(self):
            return self.getToken(nasm_x86_64_Parser.MUL, 0)

        def MWAIT(self):
            return self.getToken(nasm_x86_64_Parser.MWAIT, 0)

        def MWAITX(self):
            return self.getToken(nasm_x86_64_Parser.MWAITX, 0)

        def NEG(self):
            return self.getToken(nasm_x86_64_Parser.NEG, 0)

        def NOP(self):
            return self.getToken(nasm_x86_64_Parser.NOP, 0)

        def NOT(self):
            return self.getToken(nasm_x86_64_Parser.NOT, 0)

        def OR(self):
            return self.getToken(nasm_x86_64_Parser.OR, 0)

        def OUT(self):
            return self.getToken(nasm_x86_64_Parser.OUT, 0)

        def OUTSB(self):
            return self.getToken(nasm_x86_64_Parser.OUTSB, 0)

        def OUTSD(self):
            return self.getToken(nasm_x86_64_Parser.OUTSD, 0)

        def OUTSW(self):
            return self.getToken(nasm_x86_64_Parser.OUTSW, 0)

        def PACKSSDW(self):
            return self.getToken(nasm_x86_64_Parser.PACKSSDW, 0)

        def PACKSSWB(self):
            return self.getToken(nasm_x86_64_Parser.PACKSSWB, 0)

        def PACKUSWB(self):
            return self.getToken(nasm_x86_64_Parser.PACKUSWB, 0)

        def PADDB(self):
            return self.getToken(nasm_x86_64_Parser.PADDB, 0)

        def PADDD(self):
            return self.getToken(nasm_x86_64_Parser.PADDD, 0)

        def PADDSB(self):
            return self.getToken(nasm_x86_64_Parser.PADDSB, 0)

        def PADDSIW(self):
            return self.getToken(nasm_x86_64_Parser.PADDSIW, 0)

        def PADDSW(self):
            return self.getToken(nasm_x86_64_Parser.PADDSW, 0)

        def PADDUSB(self):
            return self.getToken(nasm_x86_64_Parser.PADDUSB, 0)

        def PADDUSW(self):
            return self.getToken(nasm_x86_64_Parser.PADDUSW, 0)

        def PADDW(self):
            return self.getToken(nasm_x86_64_Parser.PADDW, 0)

        def PAND(self):
            return self.getToken(nasm_x86_64_Parser.PAND, 0)

        def PANDN(self):
            return self.getToken(nasm_x86_64_Parser.PANDN, 0)

        def PAUSE(self):
            return self.getToken(nasm_x86_64_Parser.PAUSE, 0)

        def PAVEB(self):
            return self.getToken(nasm_x86_64_Parser.PAVEB, 0)

        def PAVGUSB(self):
            return self.getToken(nasm_x86_64_Parser.PAVGUSB, 0)

        def PCMPEQB(self):
            return self.getToken(nasm_x86_64_Parser.PCMPEQB, 0)

        def PCMPEQD(self):
            return self.getToken(nasm_x86_64_Parser.PCMPEQD, 0)

        def PCMPEQW(self):
            return self.getToken(nasm_x86_64_Parser.PCMPEQW, 0)

        def PCMPGTB(self):
            return self.getToken(nasm_x86_64_Parser.PCMPGTB, 0)

        def PCMPGTD(self):
            return self.getToken(nasm_x86_64_Parser.PCMPGTD, 0)

        def PCMPGTW(self):
            return self.getToken(nasm_x86_64_Parser.PCMPGTW, 0)

        def PDISTIB(self):
            return self.getToken(nasm_x86_64_Parser.PDISTIB, 0)

        def PF2ID(self):
            return self.getToken(nasm_x86_64_Parser.PF2ID, 0)

        def PFACC(self):
            return self.getToken(nasm_x86_64_Parser.PFACC, 0)

        def PFADD(self):
            return self.getToken(nasm_x86_64_Parser.PFADD, 0)

        def PFCMPEQ(self):
            return self.getToken(nasm_x86_64_Parser.PFCMPEQ, 0)

        def PFCMPGE(self):
            return self.getToken(nasm_x86_64_Parser.PFCMPGE, 0)

        def PFCMPGT(self):
            return self.getToken(nasm_x86_64_Parser.PFCMPGT, 0)

        def PFMAX(self):
            return self.getToken(nasm_x86_64_Parser.PFMAX, 0)

        def PFMIN(self):
            return self.getToken(nasm_x86_64_Parser.PFMIN, 0)

        def PFMUL(self):
            return self.getToken(nasm_x86_64_Parser.PFMUL, 0)

        def PFRCP(self):
            return self.getToken(nasm_x86_64_Parser.PFRCP, 0)

        def PFRCPIT1(self):
            return self.getToken(nasm_x86_64_Parser.PFRCPIT1, 0)

        def PFRCPIT2(self):
            return self.getToken(nasm_x86_64_Parser.PFRCPIT2, 0)

        def PFRSQIT1(self):
            return self.getToken(nasm_x86_64_Parser.PFRSQIT1, 0)

        def PFRSQRT(self):
            return self.getToken(nasm_x86_64_Parser.PFRSQRT, 0)

        def PFSUB(self):
            return self.getToken(nasm_x86_64_Parser.PFSUB, 0)

        def PFSUBR(self):
            return self.getToken(nasm_x86_64_Parser.PFSUBR, 0)

        def PI2FD(self):
            return self.getToken(nasm_x86_64_Parser.PI2FD, 0)

        def PMACHRIW(self):
            return self.getToken(nasm_x86_64_Parser.PMACHRIW, 0)

        def PMADDWD(self):
            return self.getToken(nasm_x86_64_Parser.PMADDWD, 0)

        def PMAGW(self):
            return self.getToken(nasm_x86_64_Parser.PMAGW, 0)

        def PMULHRIW(self):
            return self.getToken(nasm_x86_64_Parser.PMULHRIW, 0)

        def PMULHRWA(self):
            return self.getToken(nasm_x86_64_Parser.PMULHRWA, 0)

        def PMULHRWC(self):
            return self.getToken(nasm_x86_64_Parser.PMULHRWC, 0)

        def PMULHW(self):
            return self.getToken(nasm_x86_64_Parser.PMULHW, 0)

        def PMULLW(self):
            return self.getToken(nasm_x86_64_Parser.PMULLW, 0)

        def PMVGEZB(self):
            return self.getToken(nasm_x86_64_Parser.PMVGEZB, 0)

        def PMVLZB(self):
            return self.getToken(nasm_x86_64_Parser.PMVLZB, 0)

        def PMVNZB(self):
            return self.getToken(nasm_x86_64_Parser.PMVNZB, 0)

        def PMVZB(self):
            return self.getToken(nasm_x86_64_Parser.PMVZB, 0)

        def POP(self):
            return self.getToken(nasm_x86_64_Parser.POP, 0)

        def POPA(self):
            return self.getToken(nasm_x86_64_Parser.POPA, 0)

        def POPAD(self):
            return self.getToken(nasm_x86_64_Parser.POPAD, 0)

        def POPAW(self):
            return self.getToken(nasm_x86_64_Parser.POPAW, 0)

        def POPF(self):
            return self.getToken(nasm_x86_64_Parser.POPF, 0)

        def POPFD(self):
            return self.getToken(nasm_x86_64_Parser.POPFD, 0)

        def POPFQ(self):
            return self.getToken(nasm_x86_64_Parser.POPFQ, 0)

        def POPFW(self):
            return self.getToken(nasm_x86_64_Parser.POPFW, 0)

        def POR(self):
            return self.getToken(nasm_x86_64_Parser.POR, 0)

        def PREFETCH(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCH, 0)

        def PREFETCHW(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHW, 0)

        def PSLLD(self):
            return self.getToken(nasm_x86_64_Parser.PSLLD, 0)

        def PSLLQ(self):
            return self.getToken(nasm_x86_64_Parser.PSLLQ, 0)

        def PSLLW(self):
            return self.getToken(nasm_x86_64_Parser.PSLLW, 0)

        def PSRAD(self):
            return self.getToken(nasm_x86_64_Parser.PSRAD, 0)

        def PSRAW(self):
            return self.getToken(nasm_x86_64_Parser.PSRAW, 0)

        def PSRLD(self):
            return self.getToken(nasm_x86_64_Parser.PSRLD, 0)

        def PSRLQ(self):
            return self.getToken(nasm_x86_64_Parser.PSRLQ, 0)

        def PSRLW(self):
            return self.getToken(nasm_x86_64_Parser.PSRLW, 0)

        def PSUBB(self):
            return self.getToken(nasm_x86_64_Parser.PSUBB, 0)

        def PSUBD(self):
            return self.getToken(nasm_x86_64_Parser.PSUBD, 0)

        def PSUBSB(self):
            return self.getToken(nasm_x86_64_Parser.PSUBSB, 0)

        def PSUBSIW(self):
            return self.getToken(nasm_x86_64_Parser.PSUBSIW, 0)

        def PSUBSW(self):
            return self.getToken(nasm_x86_64_Parser.PSUBSW, 0)

        def PSUBUSB(self):
            return self.getToken(nasm_x86_64_Parser.PSUBUSB, 0)

        def PSUBUSW(self):
            return self.getToken(nasm_x86_64_Parser.PSUBUSW, 0)

        def PSUBW(self):
            return self.getToken(nasm_x86_64_Parser.PSUBW, 0)

        def PUNPCKHBW(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKHBW, 0)

        def PUNPCKHDQ(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKHDQ, 0)

        def PUNPCKHWD(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKHWD, 0)

        def PUNPCKLBW(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKLBW, 0)

        def PUNPCKLDQ(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKLDQ, 0)

        def PUNPCKLWD(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKLWD, 0)

        def PUSH(self):
            return self.getToken(nasm_x86_64_Parser.PUSH, 0)

        def PUSHA(self):
            return self.getToken(nasm_x86_64_Parser.PUSHA, 0)

        def PUSHAD(self):
            return self.getToken(nasm_x86_64_Parser.PUSHAD, 0)

        def PUSHAW(self):
            return self.getToken(nasm_x86_64_Parser.PUSHAW, 0)

        def PUSHF(self):
            return self.getToken(nasm_x86_64_Parser.PUSHF, 0)

        def PUSHFD(self):
            return self.getToken(nasm_x86_64_Parser.PUSHFD, 0)

        def PUSHFQ(self):
            return self.getToken(nasm_x86_64_Parser.PUSHFQ, 0)

        def PUSHFW(self):
            return self.getToken(nasm_x86_64_Parser.PUSHFW, 0)

        def PXOR(self):
            return self.getToken(nasm_x86_64_Parser.PXOR, 0)

        def RCL(self):
            return self.getToken(nasm_x86_64_Parser.RCL, 0)

        def RCR(self):
            return self.getToken(nasm_x86_64_Parser.RCR, 0)

        def RDM(self):
            return self.getToken(nasm_x86_64_Parser.RDM, 0)

        def RDMSR(self):
            return self.getToken(nasm_x86_64_Parser.RDMSR, 0)

        def RDPMC(self):
            return self.getToken(nasm_x86_64_Parser.RDPMC, 0)

        def RDSHR(self):
            return self.getToken(nasm_x86_64_Parser.RDSHR, 0)

        def RDTSC(self):
            return self.getToken(nasm_x86_64_Parser.RDTSC, 0)

        def RDTSCP(self):
            return self.getToken(nasm_x86_64_Parser.RDTSCP, 0)

        def RET(self):
            return self.getToken(nasm_x86_64_Parser.RET, 0)

        def RETD(self):
            return self.getToken(nasm_x86_64_Parser.RETD, 0)

        def RETF(self):
            return self.getToken(nasm_x86_64_Parser.RETF, 0)

        def RETFD(self):
            return self.getToken(nasm_x86_64_Parser.RETFD, 0)

        def RETFQ(self):
            return self.getToken(nasm_x86_64_Parser.RETFQ, 0)

        def RETFW(self):
            return self.getToken(nasm_x86_64_Parser.RETFW, 0)

        def RETN(self):
            return self.getToken(nasm_x86_64_Parser.RETN, 0)

        def RETND(self):
            return self.getToken(nasm_x86_64_Parser.RETND, 0)

        def RETNQ(self):
            return self.getToken(nasm_x86_64_Parser.RETNQ, 0)

        def RETNW(self):
            return self.getToken(nasm_x86_64_Parser.RETNW, 0)

        def RETQ(self):
            return self.getToken(nasm_x86_64_Parser.RETQ, 0)

        def RETW(self):
            return self.getToken(nasm_x86_64_Parser.RETW, 0)

        def ROL(self):
            return self.getToken(nasm_x86_64_Parser.ROL, 0)

        def ROR(self):
            return self.getToken(nasm_x86_64_Parser.ROR, 0)

        def RSDC(self):
            return self.getToken(nasm_x86_64_Parser.RSDC, 0)

        def RSLDT(self):
            return self.getToken(nasm_x86_64_Parser.RSLDT, 0)

        def RSM(self):
            return self.getToken(nasm_x86_64_Parser.RSM, 0)

        def RSTS(self):
            return self.getToken(nasm_x86_64_Parser.RSTS, 0)

        def SAHF(self):
            return self.getToken(nasm_x86_64_Parser.SAHF, 0)

        def SAL(self):
            return self.getToken(nasm_x86_64_Parser.SAL, 0)

        def SALC(self):
            return self.getToken(nasm_x86_64_Parser.SALC, 0)

        def SAR(self):
            return self.getToken(nasm_x86_64_Parser.SAR, 0)

        def SBB(self):
            return self.getToken(nasm_x86_64_Parser.SBB, 0)

        def SCASB(self):
            return self.getToken(nasm_x86_64_Parser.SCASB, 0)

        def SCASD(self):
            return self.getToken(nasm_x86_64_Parser.SCASD, 0)

        def SCASQ(self):
            return self.getToken(nasm_x86_64_Parser.SCASQ, 0)

        def SCASW(self):
            return self.getToken(nasm_x86_64_Parser.SCASW, 0)

        def SETA(self):
            return self.getToken(nasm_x86_64_Parser.SETA, 0)

        def SETAE(self):
            return self.getToken(nasm_x86_64_Parser.SETAE, 0)

        def SETB(self):
            return self.getToken(nasm_x86_64_Parser.SETB, 0)

        def SETBE(self):
            return self.getToken(nasm_x86_64_Parser.SETBE, 0)

        def SETC(self):
            return self.getToken(nasm_x86_64_Parser.SETC, 0)

        def SETE(self):
            return self.getToken(nasm_x86_64_Parser.SETE, 0)

        def SETG(self):
            return self.getToken(nasm_x86_64_Parser.SETG, 0)

        def SETGE(self):
            return self.getToken(nasm_x86_64_Parser.SETGE, 0)

        def SETL(self):
            return self.getToken(nasm_x86_64_Parser.SETL, 0)

        def SETLE(self):
            return self.getToken(nasm_x86_64_Parser.SETLE, 0)

        def SETNA(self):
            return self.getToken(nasm_x86_64_Parser.SETNA, 0)

        def SETNAE(self):
            return self.getToken(nasm_x86_64_Parser.SETNAE, 0)

        def SETNB(self):
            return self.getToken(nasm_x86_64_Parser.SETNB, 0)

        def SETNBE(self):
            return self.getToken(nasm_x86_64_Parser.SETNBE, 0)

        def SETNC(self):
            return self.getToken(nasm_x86_64_Parser.SETNC, 0)

        def SETNE(self):
            return self.getToken(nasm_x86_64_Parser.SETNE, 0)

        def SETNG(self):
            return self.getToken(nasm_x86_64_Parser.SETNG, 0)

        def SETNGE(self):
            return self.getToken(nasm_x86_64_Parser.SETNGE, 0)

        def SETNL(self):
            return self.getToken(nasm_x86_64_Parser.SETNL, 0)

        def SETNLE(self):
            return self.getToken(nasm_x86_64_Parser.SETNLE, 0)

        def SETNO(self):
            return self.getToken(nasm_x86_64_Parser.SETNO, 0)

        def SETNP(self):
            return self.getToken(nasm_x86_64_Parser.SETNP, 0)

        def SETNS(self):
            return self.getToken(nasm_x86_64_Parser.SETNS, 0)

        def SETNZ(self):
            return self.getToken(nasm_x86_64_Parser.SETNZ, 0)

        def SETO(self):
            return self.getToken(nasm_x86_64_Parser.SETO, 0)

        def SETP(self):
            return self.getToken(nasm_x86_64_Parser.SETP, 0)

        def SETPE(self):
            return self.getToken(nasm_x86_64_Parser.SETPE, 0)

        def SETPO(self):
            return self.getToken(nasm_x86_64_Parser.SETPO, 0)

        def SETS(self):
            return self.getToken(nasm_x86_64_Parser.SETS, 0)

        def SETZ(self):
            return self.getToken(nasm_x86_64_Parser.SETZ, 0)

        def SFENCE(self):
            return self.getToken(nasm_x86_64_Parser.SFENCE, 0)

        def SGDT(self):
            return self.getToken(nasm_x86_64_Parser.SGDT, 0)

        def SHL(self):
            return self.getToken(nasm_x86_64_Parser.SHL, 0)

        def SHLD(self):
            return self.getToken(nasm_x86_64_Parser.SHLD, 0)

        def SHR(self):
            return self.getToken(nasm_x86_64_Parser.SHR, 0)

        def SHRD(self):
            return self.getToken(nasm_x86_64_Parser.SHRD, 0)

        def SIDT(self):
            return self.getToken(nasm_x86_64_Parser.SIDT, 0)

        def SKINIT(self):
            return self.getToken(nasm_x86_64_Parser.SKINIT, 0)

        def SLDT(self):
            return self.getToken(nasm_x86_64_Parser.SLDT, 0)

        def SMI(self):
            return self.getToken(nasm_x86_64_Parser.SMI, 0)

        def SMINT(self):
            return self.getToken(nasm_x86_64_Parser.SMINT, 0)

        def SMINTOLD(self):
            return self.getToken(nasm_x86_64_Parser.SMINTOLD, 0)

        def SMSW(self):
            return self.getToken(nasm_x86_64_Parser.SMSW, 0)

        def STC(self):
            return self.getToken(nasm_x86_64_Parser.STC, 0)

        def STD(self):
            return self.getToken(nasm_x86_64_Parser.STD, 0)

        def STI(self):
            return self.getToken(nasm_x86_64_Parser.STI, 0)

        def STOSB(self):
            return self.getToken(nasm_x86_64_Parser.STOSB, 0)

        def STOSD(self):
            return self.getToken(nasm_x86_64_Parser.STOSD, 0)

        def STOSQ(self):
            return self.getToken(nasm_x86_64_Parser.STOSQ, 0)

        def STOSW(self):
            return self.getToken(nasm_x86_64_Parser.STOSW, 0)

        def STR(self):
            return self.getToken(nasm_x86_64_Parser.STR, 0)

        def SUB(self):
            return self.getToken(nasm_x86_64_Parser.SUB, 0)

        def SVDC(self):
            return self.getToken(nasm_x86_64_Parser.SVDC, 0)

        def SVLDT(self):
            return self.getToken(nasm_x86_64_Parser.SVLDT, 0)

        def SVTS(self):
            return self.getToken(nasm_x86_64_Parser.SVTS, 0)

        def SWAPGS(self):
            return self.getToken(nasm_x86_64_Parser.SWAPGS, 0)

        def SYSCALL(self):
            return self.getToken(nasm_x86_64_Parser.SYSCALL, 0)

        def SYSENTER(self):
            return self.getToken(nasm_x86_64_Parser.SYSENTER, 0)

        def SYSEXIT(self):
            return self.getToken(nasm_x86_64_Parser.SYSEXIT, 0)

        def SYSRET(self):
            return self.getToken(nasm_x86_64_Parser.SYSRET, 0)

        def TEST(self):
            return self.getToken(nasm_x86_64_Parser.TEST, 0)

        def UD0(self):
            return self.getToken(nasm_x86_64_Parser.UD0, 0)

        def UD1(self):
            return self.getToken(nasm_x86_64_Parser.UD1, 0)

        def UD2(self):
            return self.getToken(nasm_x86_64_Parser.UD2, 0)

        def UD2A(self):
            return self.getToken(nasm_x86_64_Parser.UD2A, 0)

        def UD2B(self):
            return self.getToken(nasm_x86_64_Parser.UD2B, 0)

        def UMOV(self):
            return self.getToken(nasm_x86_64_Parser.UMOV, 0)

        def VERR(self):
            return self.getToken(nasm_x86_64_Parser.VERR, 0)

        def VERW(self):
            return self.getToken(nasm_x86_64_Parser.VERW, 0)

        def WBINVD(self):
            return self.getToken(nasm_x86_64_Parser.WBINVD, 0)

        def WRMSR(self):
            return self.getToken(nasm_x86_64_Parser.WRMSR, 0)

        def WRSHR(self):
            return self.getToken(nasm_x86_64_Parser.WRSHR, 0)

        def XADD(self):
            return self.getToken(nasm_x86_64_Parser.XADD, 0)

        def XBTS(self):
            return self.getToken(nasm_x86_64_Parser.XBTS, 0)

        def XCHG(self):
            return self.getToken(nasm_x86_64_Parser.XCHG, 0)

        def XLAT(self):
            return self.getToken(nasm_x86_64_Parser.XLAT, 0)

        def XLATB(self):
            return self.getToken(nasm_x86_64_Parser.XLATB, 0)

        def XOR(self):
            return self.getToken(nasm_x86_64_Parser.XOR, 0)

        def AADD(self):
            return self.getToken(nasm_x86_64_Parser.AADD, 0)

        def AAND(self):
            return self.getToken(nasm_x86_64_Parser.AAND, 0)

        def ADCX(self):
            return self.getToken(nasm_x86_64_Parser.ADCX, 0)

        def ADDPD(self):
            return self.getToken(nasm_x86_64_Parser.ADDPD, 0)

        def ADDPS(self):
            return self.getToken(nasm_x86_64_Parser.ADDPS, 0)

        def ADDSD(self):
            return self.getToken(nasm_x86_64_Parser.ADDSD, 0)

        def ADDSS(self):
            return self.getToken(nasm_x86_64_Parser.ADDSS, 0)

        def ADDSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.ADDSUBPD, 0)

        def ADDSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.ADDSUBPS, 0)

        def ADOX(self):
            return self.getToken(nasm_x86_64_Parser.ADOX, 0)

        def AESDEC(self):
            return self.getToken(nasm_x86_64_Parser.AESDEC, 0)

        def AESDECLAST(self):
            return self.getToken(nasm_x86_64_Parser.AESDECLAST, 0)

        def AESENC(self):
            return self.getToken(nasm_x86_64_Parser.AESENC, 0)

        def AESENCLAST(self):
            return self.getToken(nasm_x86_64_Parser.AESENCLAST, 0)

        def AESIMC(self):
            return self.getToken(nasm_x86_64_Parser.AESIMC, 0)

        def AESKEYGENASSIST(self):
            return self.getToken(nasm_x86_64_Parser.AESKEYGENASSIST, 0)

        def ANDN(self):
            return self.getToken(nasm_x86_64_Parser.ANDN, 0)

        def ANDNPD(self):
            return self.getToken(nasm_x86_64_Parser.ANDNPD, 0)

        def ANDNPS(self):
            return self.getToken(nasm_x86_64_Parser.ANDNPS, 0)

        def ANDPD(self):
            return self.getToken(nasm_x86_64_Parser.ANDPD, 0)

        def ANDPS(self):
            return self.getToken(nasm_x86_64_Parser.ANDPS, 0)

        def AXOR(self):
            return self.getToken(nasm_x86_64_Parser.AXOR, 0)

        def BEXTR(self):
            return self.getToken(nasm_x86_64_Parser.BEXTR, 0)

        def BLCFILL(self):
            return self.getToken(nasm_x86_64_Parser.BLCFILL, 0)

        def BLCI(self):
            return self.getToken(nasm_x86_64_Parser.BLCI, 0)

        def BLCIC(self):
            return self.getToken(nasm_x86_64_Parser.BLCIC, 0)

        def BLCMSK(self):
            return self.getToken(nasm_x86_64_Parser.BLCMSK, 0)

        def BLCS(self):
            return self.getToken(nasm_x86_64_Parser.BLCS, 0)

        def BLENDPD(self):
            return self.getToken(nasm_x86_64_Parser.BLENDPD, 0)

        def BLENDPS(self):
            return self.getToken(nasm_x86_64_Parser.BLENDPS, 0)

        def BLENDVPD(self):
            return self.getToken(nasm_x86_64_Parser.BLENDVPD, 0)

        def BLENDVPS(self):
            return self.getToken(nasm_x86_64_Parser.BLENDVPS, 0)

        def BLSFILL(self):
            return self.getToken(nasm_x86_64_Parser.BLSFILL, 0)

        def BLSI(self):
            return self.getToken(nasm_x86_64_Parser.BLSI, 0)

        def BLSIC(self):
            return self.getToken(nasm_x86_64_Parser.BLSIC, 0)

        def BLSMSK(self):
            return self.getToken(nasm_x86_64_Parser.BLSMSK, 0)

        def BLSR(self):
            return self.getToken(nasm_x86_64_Parser.BLSR, 0)

        def BNDCL(self):
            return self.getToken(nasm_x86_64_Parser.BNDCL, 0)

        def BNDCN(self):
            return self.getToken(nasm_x86_64_Parser.BNDCN, 0)

        def BNDCU(self):
            return self.getToken(nasm_x86_64_Parser.BNDCU, 0)

        def BNDLDX(self):
            return self.getToken(nasm_x86_64_Parser.BNDLDX, 0)

        def BNDMK(self):
            return self.getToken(nasm_x86_64_Parser.BNDMK, 0)

        def BNDMOV(self):
            return self.getToken(nasm_x86_64_Parser.BNDMOV, 0)

        def BNDSTX(self):
            return self.getToken(nasm_x86_64_Parser.BNDSTX, 0)

        def BZHI(self):
            return self.getToken(nasm_x86_64_Parser.BZHI, 0)

        def CLAC(self):
            return self.getToken(nasm_x86_64_Parser.CLAC, 0)

        def CLDEMOTE(self):
            return self.getToken(nasm_x86_64_Parser.CLDEMOTE, 0)

        def CLFLUSH(self):
            return self.getToken(nasm_x86_64_Parser.CLFLUSH, 0)

        def CLFLUSHOPT(self):
            return self.getToken(nasm_x86_64_Parser.CLFLUSHOPT, 0)

        def CLGI(self):
            return self.getToken(nasm_x86_64_Parser.CLGI, 0)

        def CLRSSBSY(self):
            return self.getToken(nasm_x86_64_Parser.CLRSSBSY, 0)

        def CLUI(self):
            return self.getToken(nasm_x86_64_Parser.CLUI, 0)

        def CLWB(self):
            return self.getToken(nasm_x86_64_Parser.CLWB, 0)

        def CLZERO(self):
            return self.getToken(nasm_x86_64_Parser.CLZERO, 0)

        def CMPEQPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPEQPD, 0)

        def CMPEQPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPEQPS, 0)

        def CMPEQSD(self):
            return self.getToken(nasm_x86_64_Parser.CMPEQSD, 0)

        def CMPEQSS(self):
            return self.getToken(nasm_x86_64_Parser.CMPEQSS, 0)

        def CMPLEPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPLEPD, 0)

        def CMPLEPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPLEPS, 0)

        def CMPLESD(self):
            return self.getToken(nasm_x86_64_Parser.CMPLESD, 0)

        def CMPLESS(self):
            return self.getToken(nasm_x86_64_Parser.CMPLESS, 0)

        def CMPLTPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPLTPD, 0)

        def CMPLTPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPLTPS, 0)

        def CMPLTSD(self):
            return self.getToken(nasm_x86_64_Parser.CMPLTSD, 0)

        def CMPLTSS(self):
            return self.getToken(nasm_x86_64_Parser.CMPLTSS, 0)

        def CMPNEQPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNEQPD, 0)

        def CMPNEQPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPNEQPS, 0)

        def CMPNEQSD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNEQSD, 0)

        def CMPNEQSS(self):
            return self.getToken(nasm_x86_64_Parser.CMPNEQSS, 0)

        def CMPNLEPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLEPD, 0)

        def CMPNLEPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLEPS, 0)

        def CMPNLESD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLESD, 0)

        def CMPNLESS(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLESS, 0)

        def CMPNLTPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLTPD, 0)

        def CMPNLTPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLTPS, 0)

        def CMPNLTSD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLTSD, 0)

        def CMPNLTSS(self):
            return self.getToken(nasm_x86_64_Parser.CMPNLTSS, 0)

        def CMPNPXADD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNPXADD, 0)

        def CMPNSXADD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNSXADD, 0)

        def CMPNZXADD(self):
            return self.getToken(nasm_x86_64_Parser.CMPNZXADD, 0)

        def CMPORDPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPORDPD, 0)

        def CMPORDPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPORDPS, 0)

        def CMPORDSD(self):
            return self.getToken(nasm_x86_64_Parser.CMPORDSD, 0)

        def CMPORDSS(self):
            return self.getToken(nasm_x86_64_Parser.CMPORDSS, 0)

        def CMPOXADD(self):
            return self.getToken(nasm_x86_64_Parser.CMPOXADD, 0)

        def CMPPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPPD, 0)

        def CMPPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPPS, 0)

        def CMPPXADD(self):
            return self.getToken(nasm_x86_64_Parser.CMPPXADD, 0)

        def CMPSS(self):
            return self.getToken(nasm_x86_64_Parser.CMPSS, 0)

        def CMPSXADD(self):
            return self.getToken(nasm_x86_64_Parser.CMPSXADD, 0)

        def CMPUNORDPD(self):
            return self.getToken(nasm_x86_64_Parser.CMPUNORDPD, 0)

        def CMPUNORDPS(self):
            return self.getToken(nasm_x86_64_Parser.CMPUNORDPS, 0)

        def CMPUNORDSD(self):
            return self.getToken(nasm_x86_64_Parser.CMPUNORDSD, 0)

        def CMPUNORDSS(self):
            return self.getToken(nasm_x86_64_Parser.CMPUNORDSS, 0)

        def CMPZXADD(self):
            return self.getToken(nasm_x86_64_Parser.CMPZXADD, 0)

        def COMISD(self):
            return self.getToken(nasm_x86_64_Parser.COMISD, 0)

        def COMISS(self):
            return self.getToken(nasm_x86_64_Parser.COMISS, 0)

        def CRC32(self):
            return self.getToken(nasm_x86_64_Parser.CRC32, 0)

        def CVTDQ2PD(self):
            return self.getToken(nasm_x86_64_Parser.CVTDQ2PD, 0)

        def CVTDQ2PS(self):
            return self.getToken(nasm_x86_64_Parser.CVTDQ2PS, 0)

        def CVTPD2DQ(self):
            return self.getToken(nasm_x86_64_Parser.CVTPD2DQ, 0)

        def CVTPD2PI(self):
            return self.getToken(nasm_x86_64_Parser.CVTPD2PI, 0)

        def CVTPD2PS(self):
            return self.getToken(nasm_x86_64_Parser.CVTPD2PS, 0)

        def CVTPI2PD(self):
            return self.getToken(nasm_x86_64_Parser.CVTPI2PD, 0)

        def CVTPI2PS(self):
            return self.getToken(nasm_x86_64_Parser.CVTPI2PS, 0)

        def CVTPS2DQ(self):
            return self.getToken(nasm_x86_64_Parser.CVTPS2DQ, 0)

        def CVTPS2PD(self):
            return self.getToken(nasm_x86_64_Parser.CVTPS2PD, 0)

        def CVTPS2PI(self):
            return self.getToken(nasm_x86_64_Parser.CVTPS2PI, 0)

        def CVTSD2SI(self):
            return self.getToken(nasm_x86_64_Parser.CVTSD2SI, 0)

        def CVTSD2SS(self):
            return self.getToken(nasm_x86_64_Parser.CVTSD2SS, 0)

        def CVTSI2SD(self):
            return self.getToken(nasm_x86_64_Parser.CVTSI2SD, 0)

        def CVTSI2SS(self):
            return self.getToken(nasm_x86_64_Parser.CVTSI2SS, 0)

        def CVTSS2SD(self):
            return self.getToken(nasm_x86_64_Parser.CVTSS2SD, 0)

        def CVTSS2SI(self):
            return self.getToken(nasm_x86_64_Parser.CVTSS2SI, 0)

        def CVTTPD2DQ(self):
            return self.getToken(nasm_x86_64_Parser.CVTTPD2DQ, 0)

        def CVTTPD2PI(self):
            return self.getToken(nasm_x86_64_Parser.CVTTPD2PI, 0)

        def CVTTPS2DQ(self):
            return self.getToken(nasm_x86_64_Parser.CVTTPS2DQ, 0)

        def CVTTPS2PI(self):
            return self.getToken(nasm_x86_64_Parser.CVTTPS2PI, 0)

        def CVTTSD2SI(self):
            return self.getToken(nasm_x86_64_Parser.CVTTSD2SI, 0)

        def CVTTSS2SI(self):
            return self.getToken(nasm_x86_64_Parser.CVTTSS2SI, 0)

        def DIVPD(self):
            return self.getToken(nasm_x86_64_Parser.DIVPD, 0)

        def DIVPS(self):
            return self.getToken(nasm_x86_64_Parser.DIVPS, 0)

        def DIVSD(self):
            return self.getToken(nasm_x86_64_Parser.DIVSD, 0)

        def DIVSS(self):
            return self.getToken(nasm_x86_64_Parser.DIVSS, 0)

        def DPPD(self):
            return self.getToken(nasm_x86_64_Parser.DPPD, 0)

        def DPPS(self):
            return self.getToken(nasm_x86_64_Parser.DPPS, 0)

        def ENCLS(self):
            return self.getToken(nasm_x86_64_Parser.ENCLS, 0)

        def ENCLU(self):
            return self.getToken(nasm_x86_64_Parser.ENCLU, 0)

        def ENCLV(self):
            return self.getToken(nasm_x86_64_Parser.ENCLV, 0)

        def ENDBR32(self):
            return self.getToken(nasm_x86_64_Parser.ENDBR32, 0)

        def ENDBR64(self):
            return self.getToken(nasm_x86_64_Parser.ENDBR64, 0)

        def ENQCMD(self):
            return self.getToken(nasm_x86_64_Parser.ENQCMD, 0)

        def ENQCMDS(self):
            return self.getToken(nasm_x86_64_Parser.ENQCMDS, 0)

        def EXTRACTPS(self):
            return self.getToken(nasm_x86_64_Parser.EXTRACTPS, 0)

        def EXTRQ(self):
            return self.getToken(nasm_x86_64_Parser.EXTRQ, 0)

        def FXRSTOR(self):
            return self.getToken(nasm_x86_64_Parser.FXRSTOR, 0)

        def FXRSTOR64(self):
            return self.getToken(nasm_x86_64_Parser.FXRSTOR64, 0)

        def FXSAVE(self):
            return self.getToken(nasm_x86_64_Parser.FXSAVE, 0)

        def FXSAVE64(self):
            return self.getToken(nasm_x86_64_Parser.FXSAVE64, 0)

        def GETSEC(self):
            return self.getToken(nasm_x86_64_Parser.GETSEC, 0)

        def GF2P8AFFINEINVQB(self):
            return self.getToken(nasm_x86_64_Parser.GF2P8AFFINEINVQB, 0)

        def GF2P8AFFINEQB(self):
            return self.getToken(nasm_x86_64_Parser.GF2P8AFFINEQB, 0)

        def GF2P8MULB(self):
            return self.getToken(nasm_x86_64_Parser.GF2P8MULB, 0)

        def HADDPD(self):
            return self.getToken(nasm_x86_64_Parser.HADDPD, 0)

        def HADDPS(self):
            return self.getToken(nasm_x86_64_Parser.HADDPS, 0)

        def HINT_NOP0(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP0, 0)

        def HINT_NOP1(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP1, 0)

        def HINT_NOP10(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP10, 0)

        def HINT_NOP11(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP11, 0)

        def HINT_NOP12(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP12, 0)

        def HINT_NOP13(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP13, 0)

        def HINT_NOP14(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP14, 0)

        def HINT_NOP15(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP15, 0)

        def HINT_NOP16(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP16, 0)

        def HINT_NOP17(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP17, 0)

        def HINT_NOP18(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP18, 0)

        def HINT_NOP19(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP19, 0)

        def HINT_NOP2(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP2, 0)

        def HINT_NOP20(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP20, 0)

        def HINT_NOP21(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP21, 0)

        def HINT_NOP22(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP22, 0)

        def HINT_NOP23(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP23, 0)

        def HINT_NOP24(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP24, 0)

        def HINT_NOP25(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP25, 0)

        def HINT_NOP26(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP26, 0)

        def HINT_NOP27(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP27, 0)

        def HINT_NOP28(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP28, 0)

        def HINT_NOP29(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP29, 0)

        def HINT_NOP3(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP3, 0)

        def HINT_NOP30(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP30, 0)

        def HINT_NOP31(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP31, 0)

        def HINT_NOP32(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP32, 0)

        def HINT_NOP33(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP33, 0)

        def HINT_NOP34(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP34, 0)

        def HINT_NOP35(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP35, 0)

        def HINT_NOP36(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP36, 0)

        def HINT_NOP37(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP37, 0)

        def HINT_NOP38(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP38, 0)

        def HINT_NOP39(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP39, 0)

        def HINT_NOP4(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP4, 0)

        def HINT_NOP40(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP40, 0)

        def HINT_NOP41(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP41, 0)

        def HINT_NOP42(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP42, 0)

        def HINT_NOP43(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP43, 0)

        def HINT_NOP44(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP44, 0)

        def HINT_NOP45(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP45, 0)

        def HINT_NOP46(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP46, 0)

        def HINT_NOP47(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP47, 0)

        def HINT_NOP48(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP48, 0)

        def HINT_NOP49(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP49, 0)

        def HINT_NOP5(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP5, 0)

        def HINT_NOP50(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP50, 0)

        def HINT_NOP51(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP51, 0)

        def HINT_NOP52(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP52, 0)

        def HINT_NOP53(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP53, 0)

        def HINT_NOP54(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP54, 0)

        def HINT_NOP55(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP55, 0)

        def HINT_NOP56(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP56, 0)

        def HINT_NOP57(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP57, 0)

        def HINT_NOP58(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP58, 0)

        def HINT_NOP59(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP59, 0)

        def HINT_NOP6(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP6, 0)

        def HINT_NOP60(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP60, 0)

        def HINT_NOP61(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP61, 0)

        def HINT_NOP62(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP62, 0)

        def HINT_NOP63(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP63, 0)

        def HINT_NOP7(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP7, 0)

        def HINT_NOP8(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP8, 0)

        def HINT_NOP9(self):
            return self.getToken(nasm_x86_64_Parser.HINT_NOP9, 0)

        def HRESET(self):
            return self.getToken(nasm_x86_64_Parser.HRESET, 0)

        def HSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.HSUBPD, 0)

        def HSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.HSUBPS, 0)

        def INCSSPD(self):
            return self.getToken(nasm_x86_64_Parser.INCSSPD, 0)

        def INCSSPQ(self):
            return self.getToken(nasm_x86_64_Parser.INCSSPQ, 0)

        def INSERTPS(self):
            return self.getToken(nasm_x86_64_Parser.INSERTPS, 0)

        def INSERTQ(self):
            return self.getToken(nasm_x86_64_Parser.INSERTQ, 0)

        def INVEPT(self):
            return self.getToken(nasm_x86_64_Parser.INVEPT, 0)

        def INVVPID(self):
            return self.getToken(nasm_x86_64_Parser.INVVPID, 0)

        def KADD(self):
            return self.getToken(nasm_x86_64_Parser.KADD, 0)

        def KADDB(self):
            return self.getToken(nasm_x86_64_Parser.KADDB, 0)

        def KADDD(self):
            return self.getToken(nasm_x86_64_Parser.KADDD, 0)

        def KADDQ(self):
            return self.getToken(nasm_x86_64_Parser.KADDQ, 0)

        def KADDW(self):
            return self.getToken(nasm_x86_64_Parser.KADDW, 0)

        def KAND(self):
            return self.getToken(nasm_x86_64_Parser.KAND, 0)

        def KANDB(self):
            return self.getToken(nasm_x86_64_Parser.KANDB, 0)

        def KANDD(self):
            return self.getToken(nasm_x86_64_Parser.KANDD, 0)

        def KANDN(self):
            return self.getToken(nasm_x86_64_Parser.KANDN, 0)

        def KANDNB(self):
            return self.getToken(nasm_x86_64_Parser.KANDNB, 0)

        def KANDND(self):
            return self.getToken(nasm_x86_64_Parser.KANDND, 0)

        def KANDNQ(self):
            return self.getToken(nasm_x86_64_Parser.KANDNQ, 0)

        def KANDNW(self):
            return self.getToken(nasm_x86_64_Parser.KANDNW, 0)

        def KANDQ(self):
            return self.getToken(nasm_x86_64_Parser.KANDQ, 0)

        def KANDW(self):
            return self.getToken(nasm_x86_64_Parser.KANDW, 0)

        def KMOV(self):
            return self.getToken(nasm_x86_64_Parser.KMOV, 0)

        def KMOVB(self):
            return self.getToken(nasm_x86_64_Parser.KMOVB, 0)

        def KMOVD(self):
            return self.getToken(nasm_x86_64_Parser.KMOVD, 0)

        def KMOVQ(self):
            return self.getToken(nasm_x86_64_Parser.KMOVQ, 0)

        def KMOVW(self):
            return self.getToken(nasm_x86_64_Parser.KMOVW, 0)

        def KNOT(self):
            return self.getToken(nasm_x86_64_Parser.KNOT, 0)

        def KNOTB(self):
            return self.getToken(nasm_x86_64_Parser.KNOTB, 0)

        def KNOTD(self):
            return self.getToken(nasm_x86_64_Parser.KNOTD, 0)

        def KNOTQ(self):
            return self.getToken(nasm_x86_64_Parser.KNOTQ, 0)

        def KNOTW(self):
            return self.getToken(nasm_x86_64_Parser.KNOTW, 0)

        def KOR(self):
            return self.getToken(nasm_x86_64_Parser.KOR, 0)

        def KORB(self):
            return self.getToken(nasm_x86_64_Parser.KORB, 0)

        def KORD(self):
            return self.getToken(nasm_x86_64_Parser.KORD, 0)

        def KORQ(self):
            return self.getToken(nasm_x86_64_Parser.KORQ, 0)

        def KORTEST(self):
            return self.getToken(nasm_x86_64_Parser.KORTEST, 0)

        def KORTESTB(self):
            return self.getToken(nasm_x86_64_Parser.KORTESTB, 0)

        def KORTESTD(self):
            return self.getToken(nasm_x86_64_Parser.KORTESTD, 0)

        def KORTESTQ(self):
            return self.getToken(nasm_x86_64_Parser.KORTESTQ, 0)

        def KORTESTW(self):
            return self.getToken(nasm_x86_64_Parser.KORTESTW, 0)

        def KORW(self):
            return self.getToken(nasm_x86_64_Parser.KORW, 0)

        def KSHIFTL(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTL, 0)

        def KSHIFTLB(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTLB, 0)

        def KSHIFTLD(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTLD, 0)

        def KSHIFTLQ(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTLQ, 0)

        def KSHIFTLW(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTLW, 0)

        def KSHIFTR(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTR, 0)

        def KSHIFTRB(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTRB, 0)

        def KSHIFTRD(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTRD, 0)

        def KSHIFTRQ(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTRQ, 0)

        def KSHIFTRW(self):
            return self.getToken(nasm_x86_64_Parser.KSHIFTRW, 0)

        def KTEST(self):
            return self.getToken(nasm_x86_64_Parser.KTEST, 0)

        def KTESTB(self):
            return self.getToken(nasm_x86_64_Parser.KTESTB, 0)

        def KTESTD(self):
            return self.getToken(nasm_x86_64_Parser.KTESTD, 0)

        def KTESTQ(self):
            return self.getToken(nasm_x86_64_Parser.KTESTQ, 0)

        def KTESTW(self):
            return self.getToken(nasm_x86_64_Parser.KTESTW, 0)

        def KUNPCK(self):
            return self.getToken(nasm_x86_64_Parser.KUNPCK, 0)

        def KUNPCKBW(self):
            return self.getToken(nasm_x86_64_Parser.KUNPCKBW, 0)

        def KUNPCKDQ(self):
            return self.getToken(nasm_x86_64_Parser.KUNPCKDQ, 0)

        def KUNPCKWD(self):
            return self.getToken(nasm_x86_64_Parser.KUNPCKWD, 0)

        def KXNOR(self):
            return self.getToken(nasm_x86_64_Parser.KXNOR, 0)

        def KXNORB(self):
            return self.getToken(nasm_x86_64_Parser.KXNORB, 0)

        def KXNORD(self):
            return self.getToken(nasm_x86_64_Parser.KXNORD, 0)

        def KXNORQ(self):
            return self.getToken(nasm_x86_64_Parser.KXNORQ, 0)

        def KXNORW(self):
            return self.getToken(nasm_x86_64_Parser.KXNORW, 0)

        def KXOR(self):
            return self.getToken(nasm_x86_64_Parser.KXOR, 0)

        def KXORB(self):
            return self.getToken(nasm_x86_64_Parser.KXORB, 0)

        def KXORD(self):
            return self.getToken(nasm_x86_64_Parser.KXORD, 0)

        def KXORQ(self):
            return self.getToken(nasm_x86_64_Parser.KXORQ, 0)

        def KXORW(self):
            return self.getToken(nasm_x86_64_Parser.KXORW, 0)

        def LDDQU(self):
            return self.getToken(nasm_x86_64_Parser.LDDQU, 0)

        def LDMXCSR(self):
            return self.getToken(nasm_x86_64_Parser.LDMXCSR, 0)

        def LDTILECFG(self):
            return self.getToken(nasm_x86_64_Parser.LDTILECFG, 0)

        def LLWPCB(self):
            return self.getToken(nasm_x86_64_Parser.LLWPCB, 0)

        def LWPINS(self):
            return self.getToken(nasm_x86_64_Parser.LWPINS, 0)

        def LWPVAL(self):
            return self.getToken(nasm_x86_64_Parser.LWPVAL, 0)

        def LZCNT(self):
            return self.getToken(nasm_x86_64_Parser.LZCNT, 0)

        def MASKMOVDQU(self):
            return self.getToken(nasm_x86_64_Parser.MASKMOVDQU, 0)

        def MASKMOVQ(self):
            return self.getToken(nasm_x86_64_Parser.MASKMOVQ, 0)

        def MAXPD(self):
            return self.getToken(nasm_x86_64_Parser.MAXPD, 0)

        def MAXPS(self):
            return self.getToken(nasm_x86_64_Parser.MAXPS, 0)

        def MAXSD(self):
            return self.getToken(nasm_x86_64_Parser.MAXSD, 0)

        def MAXSS(self):
            return self.getToken(nasm_x86_64_Parser.MAXSS, 0)

        def MINPD(self):
            return self.getToken(nasm_x86_64_Parser.MINPD, 0)

        def MINPS(self):
            return self.getToken(nasm_x86_64_Parser.MINPS, 0)

        def MINSD(self):
            return self.getToken(nasm_x86_64_Parser.MINSD, 0)

        def MINSS(self):
            return self.getToken(nasm_x86_64_Parser.MINSS, 0)

        def MONTMUL(self):
            return self.getToken(nasm_x86_64_Parser.MONTMUL, 0)

        def MOVAPD(self):
            return self.getToken(nasm_x86_64_Parser.MOVAPD, 0)

        def MOVAPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVAPS, 0)

        def MOVBE(self):
            return self.getToken(nasm_x86_64_Parser.MOVBE, 0)

        def MOVDDUP(self):
            return self.getToken(nasm_x86_64_Parser.MOVDDUP, 0)

        def MOVDIR64B(self):
            return self.getToken(nasm_x86_64_Parser.MOVDIR64B, 0)

        def MOVDIRI(self):
            return self.getToken(nasm_x86_64_Parser.MOVDIRI, 0)

        def MOVDQ2Q(self):
            return self.getToken(nasm_x86_64_Parser.MOVDQ2Q, 0)

        def MOVDQA(self):
            return self.getToken(nasm_x86_64_Parser.MOVDQA, 0)

        def MOVDQU(self):
            return self.getToken(nasm_x86_64_Parser.MOVDQU, 0)

        def MOVHLPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVHLPS, 0)

        def MOVHPD(self):
            return self.getToken(nasm_x86_64_Parser.MOVHPD, 0)

        def MOVHPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVHPS, 0)

        def MOVLHPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVLHPS, 0)

        def MOVLPD(self):
            return self.getToken(nasm_x86_64_Parser.MOVLPD, 0)

        def MOVLPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVLPS, 0)

        def MOVMSKPD(self):
            return self.getToken(nasm_x86_64_Parser.MOVMSKPD, 0)

        def MOVMSKPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVMSKPS, 0)

        def MOVNTDQ(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTDQ, 0)

        def MOVNTDQA(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTDQA, 0)

        def MOVNTI(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTI, 0)

        def MOVNTPD(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTPD, 0)

        def MOVNTPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTPS, 0)

        def MOVNTQ(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTQ, 0)

        def MOVNTSD(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTSD, 0)

        def MOVNTSS(self):
            return self.getToken(nasm_x86_64_Parser.MOVNTSS, 0)

        def MOVQ2DQ(self):
            return self.getToken(nasm_x86_64_Parser.MOVQ2DQ, 0)

        def MOVSHDUP(self):
            return self.getToken(nasm_x86_64_Parser.MOVSHDUP, 0)

        def MOVSLDUP(self):
            return self.getToken(nasm_x86_64_Parser.MOVSLDUP, 0)

        def MOVSS(self):
            return self.getToken(nasm_x86_64_Parser.MOVSS, 0)

        def MOVUPD(self):
            return self.getToken(nasm_x86_64_Parser.MOVUPD, 0)

        def MOVUPS(self):
            return self.getToken(nasm_x86_64_Parser.MOVUPS, 0)

        def MPSADBW(self):
            return self.getToken(nasm_x86_64_Parser.MPSADBW, 0)

        def MULPD(self):
            return self.getToken(nasm_x86_64_Parser.MULPD, 0)

        def MULPS(self):
            return self.getToken(nasm_x86_64_Parser.MULPS, 0)

        def MULSD(self):
            return self.getToken(nasm_x86_64_Parser.MULSD, 0)

        def MULSS(self):
            return self.getToken(nasm_x86_64_Parser.MULSS, 0)

        def MULX(self):
            return self.getToken(nasm_x86_64_Parser.MULX, 0)

        def ORPD(self):
            return self.getToken(nasm_x86_64_Parser.ORPD, 0)

        def ORPS(self):
            return self.getToken(nasm_x86_64_Parser.ORPS, 0)

        def PABSB(self):
            return self.getToken(nasm_x86_64_Parser.PABSB, 0)

        def PABSD(self):
            return self.getToken(nasm_x86_64_Parser.PABSD, 0)

        def PABSW(self):
            return self.getToken(nasm_x86_64_Parser.PABSW, 0)

        def PACKUSDW(self):
            return self.getToken(nasm_x86_64_Parser.PACKUSDW, 0)

        def PADDQ(self):
            return self.getToken(nasm_x86_64_Parser.PADDQ, 0)

        def PALIGNR(self):
            return self.getToken(nasm_x86_64_Parser.PALIGNR, 0)

        def PAVGB(self):
            return self.getToken(nasm_x86_64_Parser.PAVGB, 0)

        def PAVGW(self):
            return self.getToken(nasm_x86_64_Parser.PAVGW, 0)

        def PBLENDVB(self):
            return self.getToken(nasm_x86_64_Parser.PBLENDVB, 0)

        def PBLENDW(self):
            return self.getToken(nasm_x86_64_Parser.PBLENDW, 0)

        def PCLMULHQHQDQ(self):
            return self.getToken(nasm_x86_64_Parser.PCLMULHQHQDQ, 0)

        def PCLMULHQLQDQ(self):
            return self.getToken(nasm_x86_64_Parser.PCLMULHQLQDQ, 0)

        def PCLMULLQHQDQ(self):
            return self.getToken(nasm_x86_64_Parser.PCLMULLQHQDQ, 0)

        def PCLMULLQLQDQ(self):
            return self.getToken(nasm_x86_64_Parser.PCLMULLQLQDQ, 0)

        def PCLMULQDQ(self):
            return self.getToken(nasm_x86_64_Parser.PCLMULQDQ, 0)

        def PCMPEQQ(self):
            return self.getToken(nasm_x86_64_Parser.PCMPEQQ, 0)

        def PCMPESTRI(self):
            return self.getToken(nasm_x86_64_Parser.PCMPESTRI, 0)

        def PCMPESTRM(self):
            return self.getToken(nasm_x86_64_Parser.PCMPESTRM, 0)

        def PCMPGTQ(self):
            return self.getToken(nasm_x86_64_Parser.PCMPGTQ, 0)

        def PCMPISTRI(self):
            return self.getToken(nasm_x86_64_Parser.PCMPISTRI, 0)

        def PCMPISTRM(self):
            return self.getToken(nasm_x86_64_Parser.PCMPISTRM, 0)

        def PCOMMIT(self):
            return self.getToken(nasm_x86_64_Parser.PCOMMIT, 0)

        def PCONFIG(self):
            return self.getToken(nasm_x86_64_Parser.PCONFIG, 0)

        def PDEP(self):
            return self.getToken(nasm_x86_64_Parser.PDEP, 0)

        def PEXT(self):
            return self.getToken(nasm_x86_64_Parser.PEXT, 0)

        def PEXTRB(self):
            return self.getToken(nasm_x86_64_Parser.PEXTRB, 0)

        def PEXTRD(self):
            return self.getToken(nasm_x86_64_Parser.PEXTRD, 0)

        def PEXTRQ(self):
            return self.getToken(nasm_x86_64_Parser.PEXTRQ, 0)

        def PEXTRW(self):
            return self.getToken(nasm_x86_64_Parser.PEXTRW, 0)

        def PF2IW(self):
            return self.getToken(nasm_x86_64_Parser.PF2IW, 0)

        def PFNACC(self):
            return self.getToken(nasm_x86_64_Parser.PFNACC, 0)

        def PFPNACC(self):
            return self.getToken(nasm_x86_64_Parser.PFPNACC, 0)

        def PFRCPV(self):
            return self.getToken(nasm_x86_64_Parser.PFRCPV, 0)

        def PFRSQRTV(self):
            return self.getToken(nasm_x86_64_Parser.PFRSQRTV, 0)

        def PHADDD(self):
            return self.getToken(nasm_x86_64_Parser.PHADDD, 0)

        def PHADDSW(self):
            return self.getToken(nasm_x86_64_Parser.PHADDSW, 0)

        def PHADDW(self):
            return self.getToken(nasm_x86_64_Parser.PHADDW, 0)

        def PHMINPOSUW(self):
            return self.getToken(nasm_x86_64_Parser.PHMINPOSUW, 0)

        def PHSUBD(self):
            return self.getToken(nasm_x86_64_Parser.PHSUBD, 0)

        def PHSUBSW(self):
            return self.getToken(nasm_x86_64_Parser.PHSUBSW, 0)

        def PHSUBW(self):
            return self.getToken(nasm_x86_64_Parser.PHSUBW, 0)

        def PI2FW(self):
            return self.getToken(nasm_x86_64_Parser.PI2FW, 0)

        def PINSRB(self):
            return self.getToken(nasm_x86_64_Parser.PINSRB, 0)

        def PINSRD(self):
            return self.getToken(nasm_x86_64_Parser.PINSRD, 0)

        def PINSRQ(self):
            return self.getToken(nasm_x86_64_Parser.PINSRQ, 0)

        def PINSRW(self):
            return self.getToken(nasm_x86_64_Parser.PINSRW, 0)

        def PMADDUBSW(self):
            return self.getToken(nasm_x86_64_Parser.PMADDUBSW, 0)

        def PMAXSB(self):
            return self.getToken(nasm_x86_64_Parser.PMAXSB, 0)

        def PMAXSD(self):
            return self.getToken(nasm_x86_64_Parser.PMAXSD, 0)

        def PMAXSW(self):
            return self.getToken(nasm_x86_64_Parser.PMAXSW, 0)

        def PMAXUB(self):
            return self.getToken(nasm_x86_64_Parser.PMAXUB, 0)

        def PMAXUD(self):
            return self.getToken(nasm_x86_64_Parser.PMAXUD, 0)

        def PMAXUW(self):
            return self.getToken(nasm_x86_64_Parser.PMAXUW, 0)

        def PMINSB(self):
            return self.getToken(nasm_x86_64_Parser.PMINSB, 0)

        def PMINSD(self):
            return self.getToken(nasm_x86_64_Parser.PMINSD, 0)

        def PMINSW(self):
            return self.getToken(nasm_x86_64_Parser.PMINSW, 0)

        def PMINUB(self):
            return self.getToken(nasm_x86_64_Parser.PMINUB, 0)

        def PMINUD(self):
            return self.getToken(nasm_x86_64_Parser.PMINUD, 0)

        def PMINUW(self):
            return self.getToken(nasm_x86_64_Parser.PMINUW, 0)

        def PMOVMSKB(self):
            return self.getToken(nasm_x86_64_Parser.PMOVMSKB, 0)

        def PMOVSXBD(self):
            return self.getToken(nasm_x86_64_Parser.PMOVSXBD, 0)

        def PMOVSXBQ(self):
            return self.getToken(nasm_x86_64_Parser.PMOVSXBQ, 0)

        def PMOVSXBW(self):
            return self.getToken(nasm_x86_64_Parser.PMOVSXBW, 0)

        def PMOVSXDQ(self):
            return self.getToken(nasm_x86_64_Parser.PMOVSXDQ, 0)

        def PMOVSXWD(self):
            return self.getToken(nasm_x86_64_Parser.PMOVSXWD, 0)

        def PMOVSXWQ(self):
            return self.getToken(nasm_x86_64_Parser.PMOVSXWQ, 0)

        def PMOVZXBD(self):
            return self.getToken(nasm_x86_64_Parser.PMOVZXBD, 0)

        def PMOVZXBQ(self):
            return self.getToken(nasm_x86_64_Parser.PMOVZXBQ, 0)

        def PMOVZXBW(self):
            return self.getToken(nasm_x86_64_Parser.PMOVZXBW, 0)

        def PMOVZXDQ(self):
            return self.getToken(nasm_x86_64_Parser.PMOVZXDQ, 0)

        def PMOVZXWD(self):
            return self.getToken(nasm_x86_64_Parser.PMOVZXWD, 0)

        def PMOVZXWQ(self):
            return self.getToken(nasm_x86_64_Parser.PMOVZXWQ, 0)

        def PMULDQ(self):
            return self.getToken(nasm_x86_64_Parser.PMULDQ, 0)

        def PMULHRSW(self):
            return self.getToken(nasm_x86_64_Parser.PMULHRSW, 0)

        def PMULHUW(self):
            return self.getToken(nasm_x86_64_Parser.PMULHUW, 0)

        def PMULLD(self):
            return self.getToken(nasm_x86_64_Parser.PMULLD, 0)

        def PMULUDQ(self):
            return self.getToken(nasm_x86_64_Parser.PMULUDQ, 0)

        def POPCNT(self):
            return self.getToken(nasm_x86_64_Parser.POPCNT, 0)

        def PREFETCHIT0(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHIT0, 0)

        def PREFETCHIT1(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHIT1, 0)

        def PREFETCHNTA(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHNTA, 0)

        def PREFETCHT0(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHT0, 0)

        def PREFETCHT1(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHT1, 0)

        def PREFETCHT2(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHT2, 0)

        def PREFETCHWT1(self):
            return self.getToken(nasm_x86_64_Parser.PREFETCHWT1, 0)

        def PSADBW(self):
            return self.getToken(nasm_x86_64_Parser.PSADBW, 0)

        def PSHUFB(self):
            return self.getToken(nasm_x86_64_Parser.PSHUFB, 0)

        def PSHUFD(self):
            return self.getToken(nasm_x86_64_Parser.PSHUFD, 0)

        def PSHUFHW(self):
            return self.getToken(nasm_x86_64_Parser.PSHUFHW, 0)

        def PSHUFLW(self):
            return self.getToken(nasm_x86_64_Parser.PSHUFLW, 0)

        def PSHUFW(self):
            return self.getToken(nasm_x86_64_Parser.PSHUFW, 0)

        def PSIGNB(self):
            return self.getToken(nasm_x86_64_Parser.PSIGNB, 0)

        def PSIGND(self):
            return self.getToken(nasm_x86_64_Parser.PSIGND, 0)

        def PSIGNW(self):
            return self.getToken(nasm_x86_64_Parser.PSIGNW, 0)

        def PSLLDQ(self):
            return self.getToken(nasm_x86_64_Parser.PSLLDQ, 0)

        def PSRLDQ(self):
            return self.getToken(nasm_x86_64_Parser.PSRLDQ, 0)

        def PSUBQ(self):
            return self.getToken(nasm_x86_64_Parser.PSUBQ, 0)

        def PSWAPD(self):
            return self.getToken(nasm_x86_64_Parser.PSWAPD, 0)

        def PTEST(self):
            return self.getToken(nasm_x86_64_Parser.PTEST, 0)

        def PTWRITE(self):
            return self.getToken(nasm_x86_64_Parser.PTWRITE, 0)

        def PUNPCKHQDQ(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKHQDQ, 0)

        def PUNPCKLQDQ(self):
            return self.getToken(nasm_x86_64_Parser.PUNPCKLQDQ, 0)

        def PVALIDATE(self):
            return self.getToken(nasm_x86_64_Parser.PVALIDATE, 0)

        def RCPPS(self):
            return self.getToken(nasm_x86_64_Parser.RCPPS, 0)

        def RCPSS(self):
            return self.getToken(nasm_x86_64_Parser.RCPSS, 0)

        def RDFSBASE(self):
            return self.getToken(nasm_x86_64_Parser.RDFSBASE, 0)

        def RDGSBASE(self):
            return self.getToken(nasm_x86_64_Parser.RDGSBASE, 0)

        def RDMSRLIST(self):
            return self.getToken(nasm_x86_64_Parser.RDMSRLIST, 0)

        def RDPID(self):
            return self.getToken(nasm_x86_64_Parser.RDPID, 0)

        def RDPKRU(self):
            return self.getToken(nasm_x86_64_Parser.RDPKRU, 0)

        def RDRAND(self):
            return self.getToken(nasm_x86_64_Parser.RDRAND, 0)

        def RDSEED(self):
            return self.getToken(nasm_x86_64_Parser.RDSEED, 0)

        def RDSSPD(self):
            return self.getToken(nasm_x86_64_Parser.RDSSPD, 0)

        def RDSSPQ(self):
            return self.getToken(nasm_x86_64_Parser.RDSSPQ, 0)

        def RMPADJUST(self):
            return self.getToken(nasm_x86_64_Parser.RMPADJUST, 0)

        def RORX(self):
            return self.getToken(nasm_x86_64_Parser.RORX, 0)

        def ROUNDPD(self):
            return self.getToken(nasm_x86_64_Parser.ROUNDPD, 0)

        def ROUNDPS(self):
            return self.getToken(nasm_x86_64_Parser.ROUNDPS, 0)

        def ROUNDSD(self):
            return self.getToken(nasm_x86_64_Parser.ROUNDSD, 0)

        def ROUNDSS(self):
            return self.getToken(nasm_x86_64_Parser.ROUNDSS, 0)

        def RSQRTPS(self):
            return self.getToken(nasm_x86_64_Parser.RSQRTPS, 0)

        def RSQRTSS(self):
            return self.getToken(nasm_x86_64_Parser.RSQRTSS, 0)

        def RSTORSSP(self):
            return self.getToken(nasm_x86_64_Parser.RSTORSSP, 0)

        def SARX(self):
            return self.getToken(nasm_x86_64_Parser.SARX, 0)

        def SAVEPREVSSP(self):
            return self.getToken(nasm_x86_64_Parser.SAVEPREVSSP, 0)

        def SENDUIPI(self):
            return self.getToken(nasm_x86_64_Parser.SENDUIPI, 0)

        def SERIALIZE(self):
            return self.getToken(nasm_x86_64_Parser.SERIALIZE, 0)

        def SETSSBSY(self):
            return self.getToken(nasm_x86_64_Parser.SETSSBSY, 0)

        def SHA1MSG1(self):
            return self.getToken(nasm_x86_64_Parser.SHA1MSG1, 0)

        def SHA1MSG2(self):
            return self.getToken(nasm_x86_64_Parser.SHA1MSG2, 0)

        def SHA1NEXTE(self):
            return self.getToken(nasm_x86_64_Parser.SHA1NEXTE, 0)

        def SHA1RNDS4(self):
            return self.getToken(nasm_x86_64_Parser.SHA1RNDS4, 0)

        def SHA256MSG1(self):
            return self.getToken(nasm_x86_64_Parser.SHA256MSG1, 0)

        def SHA256MSG2(self):
            return self.getToken(nasm_x86_64_Parser.SHA256MSG2, 0)

        def SHA256RNDS2(self):
            return self.getToken(nasm_x86_64_Parser.SHA256RNDS2, 0)

        def SHLX(self):
            return self.getToken(nasm_x86_64_Parser.SHLX, 0)

        def SHRX(self):
            return self.getToken(nasm_x86_64_Parser.SHRX, 0)

        def SHUFPD(self):
            return self.getToken(nasm_x86_64_Parser.SHUFPD, 0)

        def SHUFPS(self):
            return self.getToken(nasm_x86_64_Parser.SHUFPS, 0)

        def SLWPCB(self):
            return self.getToken(nasm_x86_64_Parser.SLWPCB, 0)

        def SQRTPD(self):
            return self.getToken(nasm_x86_64_Parser.SQRTPD, 0)

        def SQRTPS(self):
            return self.getToken(nasm_x86_64_Parser.SQRTPS, 0)

        def SQRTSD(self):
            return self.getToken(nasm_x86_64_Parser.SQRTSD, 0)

        def SQRTSS(self):
            return self.getToken(nasm_x86_64_Parser.SQRTSS, 0)

        def STAC(self):
            return self.getToken(nasm_x86_64_Parser.STAC, 0)

        def STGI(self):
            return self.getToken(nasm_x86_64_Parser.STGI, 0)

        def STMXCSR(self):
            return self.getToken(nasm_x86_64_Parser.STMXCSR, 0)

        def STTILECFG(self):
            return self.getToken(nasm_x86_64_Parser.STTILECFG, 0)

        def STUI(self):
            return self.getToken(nasm_x86_64_Parser.STUI, 0)

        def SUBPD(self):
            return self.getToken(nasm_x86_64_Parser.SUBPD, 0)

        def SUBPS(self):
            return self.getToken(nasm_x86_64_Parser.SUBPS, 0)

        def SUBSD(self):
            return self.getToken(nasm_x86_64_Parser.SUBSD, 0)

        def SUBSS(self):
            return self.getToken(nasm_x86_64_Parser.SUBSS, 0)

        def T1MSKC(self):
            return self.getToken(nasm_x86_64_Parser.T1MSKC, 0)

        def TDPBF16PS(self):
            return self.getToken(nasm_x86_64_Parser.TDPBF16PS, 0)

        def TDPBSSD(self):
            return self.getToken(nasm_x86_64_Parser.TDPBSSD, 0)

        def TDPBSUD(self):
            return self.getToken(nasm_x86_64_Parser.TDPBSUD, 0)

        def TDPBUSD(self):
            return self.getToken(nasm_x86_64_Parser.TDPBUSD, 0)

        def TDPBUUD(self):
            return self.getToken(nasm_x86_64_Parser.TDPBUUD, 0)

        def TESTUI(self):
            return self.getToken(nasm_x86_64_Parser.TESTUI, 0)

        def TILELOADD(self):
            return self.getToken(nasm_x86_64_Parser.TILELOADD, 0)

        def TILELOADDT1(self):
            return self.getToken(nasm_x86_64_Parser.TILELOADDT1, 0)

        def TILERELEASE(self):
            return self.getToken(nasm_x86_64_Parser.TILERELEASE, 0)

        def TILESTORED(self):
            return self.getToken(nasm_x86_64_Parser.TILESTORED, 0)

        def TILEZERO(self):
            return self.getToken(nasm_x86_64_Parser.TILEZERO, 0)

        def TPAUSE(self):
            return self.getToken(nasm_x86_64_Parser.TPAUSE, 0)

        def TZCNT(self):
            return self.getToken(nasm_x86_64_Parser.TZCNT, 0)

        def TZMSK(self):
            return self.getToken(nasm_x86_64_Parser.TZMSK, 0)

        def UCOMISD(self):
            return self.getToken(nasm_x86_64_Parser.UCOMISD, 0)

        def UCOMISS(self):
            return self.getToken(nasm_x86_64_Parser.UCOMISS, 0)

        def UIRET(self):
            return self.getToken(nasm_x86_64_Parser.UIRET, 0)

        def UMONITOR(self):
            return self.getToken(nasm_x86_64_Parser.UMONITOR, 0)

        def UMWAIT(self):
            return self.getToken(nasm_x86_64_Parser.UMWAIT, 0)

        def UNPCKHPD(self):
            return self.getToken(nasm_x86_64_Parser.UNPCKHPD, 0)

        def UNPCKHPS(self):
            return self.getToken(nasm_x86_64_Parser.UNPCKHPS, 0)

        def UNPCKLPD(self):
            return self.getToken(nasm_x86_64_Parser.UNPCKLPD, 0)

        def UNPCKLPS(self):
            return self.getToken(nasm_x86_64_Parser.UNPCKLPS, 0)

        def V4DPWSSD(self):
            return self.getToken(nasm_x86_64_Parser.V4DPWSSD, 0)

        def V4DPWSSDS(self):
            return self.getToken(nasm_x86_64_Parser.V4DPWSSDS, 0)

        def V4FMADDPS(self):
            return self.getToken(nasm_x86_64_Parser.V4FMADDPS, 0)

        def V4FMADDSS(self):
            return self.getToken(nasm_x86_64_Parser.V4FMADDSS, 0)

        def V4FNMADDPS(self):
            return self.getToken(nasm_x86_64_Parser.V4FNMADDPS, 0)

        def V4FNMADDSS(self):
            return self.getToken(nasm_x86_64_Parser.V4FNMADDSS, 0)

        def VADDPD(self):
            return self.getToken(nasm_x86_64_Parser.VADDPD, 0)

        def VADDPH(self):
            return self.getToken(nasm_x86_64_Parser.VADDPH, 0)

        def VADDPS(self):
            return self.getToken(nasm_x86_64_Parser.VADDPS, 0)

        def VADDSD(self):
            return self.getToken(nasm_x86_64_Parser.VADDSD, 0)

        def VADDSH(self):
            return self.getToken(nasm_x86_64_Parser.VADDSH, 0)

        def VADDSS(self):
            return self.getToken(nasm_x86_64_Parser.VADDSS, 0)

        def VADDSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.VADDSUBPD, 0)

        def VADDSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.VADDSUBPS, 0)

        def VAESDEC(self):
            return self.getToken(nasm_x86_64_Parser.VAESDEC, 0)

        def VAESDECLAST(self):
            return self.getToken(nasm_x86_64_Parser.VAESDECLAST, 0)

        def VAESENC(self):
            return self.getToken(nasm_x86_64_Parser.VAESENC, 0)

        def VAESENCLAST(self):
            return self.getToken(nasm_x86_64_Parser.VAESENCLAST, 0)

        def VAESIMC(self):
            return self.getToken(nasm_x86_64_Parser.VAESIMC, 0)

        def VAESKEYGENASSIST(self):
            return self.getToken(nasm_x86_64_Parser.VAESKEYGENASSIST, 0)

        def VALIGND(self):
            return self.getToken(nasm_x86_64_Parser.VALIGND, 0)

        def VALIGNQ(self):
            return self.getToken(nasm_x86_64_Parser.VALIGNQ, 0)

        def VANDNPD(self):
            return self.getToken(nasm_x86_64_Parser.VANDNPD, 0)

        def VANDNPS(self):
            return self.getToken(nasm_x86_64_Parser.VANDNPS, 0)

        def VANDPD(self):
            return self.getToken(nasm_x86_64_Parser.VANDPD, 0)

        def VANDPS(self):
            return self.getToken(nasm_x86_64_Parser.VANDPS, 0)

        def VBCSTNEBF16PS(self):
            return self.getToken(nasm_x86_64_Parser.VBCSTNEBF16PS, 0)

        def VBCSTNESH2PS(self):
            return self.getToken(nasm_x86_64_Parser.VBCSTNESH2PS, 0)

        def VBLENDMPD(self):
            return self.getToken(nasm_x86_64_Parser.VBLENDMPD, 0)

        def VBLENDMPS(self):
            return self.getToken(nasm_x86_64_Parser.VBLENDMPS, 0)

        def VBLENDPD(self):
            return self.getToken(nasm_x86_64_Parser.VBLENDPD, 0)

        def VBLENDPS(self):
            return self.getToken(nasm_x86_64_Parser.VBLENDPS, 0)

        def VBLENDVPD(self):
            return self.getToken(nasm_x86_64_Parser.VBLENDVPD, 0)

        def VBLENDVPS(self):
            return self.getToken(nasm_x86_64_Parser.VBLENDVPS, 0)

        def VBROADCASTF128(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTF128, 0)

        def VBROADCASTF32X2(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTF32X2, 0)

        def VBROADCASTF32X4(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTF32X4, 0)

        def VBROADCASTF32X8(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTF32X8, 0)

        def VBROADCASTF64X2(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTF64X2, 0)

        def VBROADCASTF64X4(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTF64X4, 0)

        def VBROADCASTI128(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTI128, 0)

        def VBROADCASTI32X2(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTI32X2, 0)

        def VBROADCASTI32X4(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTI32X4, 0)

        def VBROADCASTI32X8(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTI32X8, 0)

        def VBROADCASTI64X2(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTI64X2, 0)

        def VBROADCASTI64X4(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTI64X4, 0)

        def VBROADCASTSD(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTSD, 0)

        def VBROADCASTSS(self):
            return self.getToken(nasm_x86_64_Parser.VBROADCASTSS, 0)

        def VCMPEQ_OQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OQPD, 0)

        def VCMPEQ_OQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OQPS, 0)

        def VCMPEQ_OQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OQSD, 0)

        def VCMPEQ_OQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OQSS, 0)

        def VCMPEQ_OSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OSPD, 0)

        def VCMPEQ_OSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OSPS, 0)

        def VCMPEQ_OSSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OSSD, 0)

        def VCMPEQ_OSSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_OSSS, 0)

        def VCMPEQ_UQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_UQPD, 0)

        def VCMPEQ_UQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_UQPS, 0)

        def VCMPEQ_UQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_UQSD, 0)

        def VCMPEQ_UQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_UQSS, 0)

        def VCMPEQ_USPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_USPD, 0)

        def VCMPEQ_USPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_USPS, 0)

        def VCMPEQ_USSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_USSD, 0)

        def VCMPEQ_USSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQ_USSS, 0)

        def VCMPEQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQPD, 0)

        def VCMPEQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQPS, 0)

        def VCMPEQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQSD, 0)

        def VCMPEQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPEQSS, 0)

        def VCMPFALSE_OQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OQPD, 0)

        def VCMPFALSE_OQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OQPS, 0)

        def VCMPFALSE_OQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OQSD, 0)

        def VCMPFALSE_OQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OQSS, 0)

        def VCMPFALSE_OSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OSPD, 0)

        def VCMPFALSE_OSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OSPS, 0)

        def VCMPFALSE_OSSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OSSD, 0)

        def VCMPFALSE_OSSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSE_OSSS, 0)

        def VCMPFALSEPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSEPD, 0)

        def VCMPFALSEPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSEPS, 0)

        def VCMPFALSESD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSESD, 0)

        def VCMPFALSESS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPFALSESS, 0)

        def VCMPGE_OQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OQPD, 0)

        def VCMPGE_OQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OQPS, 0)

        def VCMPGE_OQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OQSD, 0)

        def VCMPGE_OQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OQSS, 0)

        def VCMPGE_OSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OSPD, 0)

        def VCMPGE_OSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OSPS, 0)

        def VCMPGE_OSSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OSSD, 0)

        def VCMPGE_OSSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGE_OSSS, 0)

        def VCMPGEPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGEPD, 0)

        def VCMPGEPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGEPS, 0)

        def VCMPGESD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGESD, 0)

        def VCMPGESS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGESS, 0)

        def VCMPGT_OQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OQPD, 0)

        def VCMPGT_OQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OQPS, 0)

        def VCMPGT_OQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OQSD, 0)

        def VCMPGT_OQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OQSS, 0)

        def VCMPGT_OSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OSPD, 0)

        def VCMPGT_OSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OSPS, 0)

        def VCMPGT_OSSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OSSD, 0)

        def VCMPGT_OSSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGT_OSSS, 0)

        def VCMPGTPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGTPD, 0)

        def VCMPGTPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGTPS, 0)

        def VCMPGTSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGTSD, 0)

        def VCMPGTSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPGTSS, 0)

        def VCMPLE_OQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OQPD, 0)

        def VCMPLE_OQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OQPS, 0)

        def VCMPLE_OQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OQSD, 0)

        def VCMPLE_OQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OQSS, 0)

        def VCMPLE_OSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OSPD, 0)

        def VCMPLE_OSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OSPS, 0)

        def VCMPLE_OSSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OSSD, 0)

        def VCMPLE_OSSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLE_OSSS, 0)

        def VCMPLEPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLEPD, 0)

        def VCMPLEPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLEPS, 0)

        def VCMPLESD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLESD, 0)

        def VCMPLESS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLESS, 0)

        def VCMPLT_OQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OQPD, 0)

        def VCMPLT_OQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OQPS, 0)

        def VCMPLT_OQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OQSD, 0)

        def VCMPLT_OQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OQSS, 0)

        def VCMPLT_OSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OSPD, 0)

        def VCMPLT_OSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OSPS, 0)

        def VCMPLT_OSSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OSSD, 0)

        def VCMPLT_OSSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLT_OSSS, 0)

        def VCMPLTPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLTPD, 0)

        def VCMPLTPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLTPS, 0)

        def VCMPLTSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLTSD, 0)

        def VCMPLTSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPLTSS, 0)

        def VCMPNEQ_OQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OQPD, 0)

        def VCMPNEQ_OQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OQPS, 0)

        def VCMPNEQ_OQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OQSD, 0)

        def VCMPNEQ_OQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OQSS, 0)

        def VCMPNEQ_OSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OSPD, 0)

        def VCMPNEQ_OSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OSPS, 0)

        def VCMPNEQ_OSSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OSSD, 0)

        def VCMPNEQ_OSSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_OSSS, 0)

        def VCMPNEQ_UQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_UQPD, 0)

        def VCMPNEQ_UQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_UQPS, 0)

        def VCMPNEQ_UQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_UQSD, 0)

        def VCMPNEQ_UQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_UQSS, 0)

        def VCMPNEQ_USPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_USPD, 0)

        def VCMPNEQ_USPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_USPS, 0)

        def VCMPNEQ_USSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_USSD, 0)

        def VCMPNEQ_USSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQ_USSS, 0)

        def VCMPNEQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQPD, 0)

        def VCMPNEQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQPS, 0)

        def VCMPNEQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQSD, 0)

        def VCMPNEQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNEQSS, 0)

        def VCMPNGE_UQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_UQPD, 0)

        def VCMPNGE_UQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_UQPS, 0)

        def VCMPNGE_UQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_UQSD, 0)

        def VCMPNGE_UQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_UQSS, 0)

        def VCMPNGE_USPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_USPD, 0)

        def VCMPNGE_USPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_USPS, 0)

        def VCMPNGE_USSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_USSD, 0)

        def VCMPNGE_USSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGE_USSS, 0)

        def VCMPNGEPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGEPD, 0)

        def VCMPNGEPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGEPS, 0)

        def VCMPNGESD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGESD, 0)

        def VCMPNGESS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGESS, 0)

        def VCMPNGT_UQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_UQPD, 0)

        def VCMPNGT_UQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_UQPS, 0)

        def VCMPNGT_UQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_UQSD, 0)

        def VCMPNGT_UQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_UQSS, 0)

        def VCMPNGT_USPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_USPD, 0)

        def VCMPNGT_USPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_USPS, 0)

        def VCMPNGT_USSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_USSD, 0)

        def VCMPNGT_USSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGT_USSS, 0)

        def VCMPNGTPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGTPD, 0)

        def VCMPNGTPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGTPS, 0)

        def VCMPNGTSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGTSD, 0)

        def VCMPNGTSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNGTSS, 0)

        def VCMPNLE_UQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_UQPD, 0)

        def VCMPNLE_UQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_UQPS, 0)

        def VCMPNLE_UQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_UQSD, 0)

        def VCMPNLE_UQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_UQSS, 0)

        def VCMPNLE_USPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_USPD, 0)

        def VCMPNLE_USPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_USPS, 0)

        def VCMPNLE_USSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_USSD, 0)

        def VCMPNLE_USSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLE_USSS, 0)

        def VCMPNLEPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLEPD, 0)

        def VCMPNLEPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLEPS, 0)

        def VCMPNLESD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLESD, 0)

        def VCMPNLESS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLESS, 0)

        def VCMPNLT_UQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_UQPD, 0)

        def VCMPNLT_UQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_UQPS, 0)

        def VCMPNLT_UQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_UQSD, 0)

        def VCMPNLT_UQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_UQSS, 0)

        def VCMPNLT_USPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_USPD, 0)

        def VCMPNLT_USPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_USPS, 0)

        def VCMPNLT_USSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_USSD, 0)

        def VCMPNLT_USSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLT_USSS, 0)

        def VCMPNLTPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLTPD, 0)

        def VCMPNLTPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLTPS, 0)

        def VCMPNLTSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLTSD, 0)

        def VCMPNLTSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPNLTSS, 0)

        def VCMPORD_QPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_QPD, 0)

        def VCMPORD_QPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_QPS, 0)

        def VCMPORD_QSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_QSD, 0)

        def VCMPORD_QSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_QSS, 0)

        def VCMPORD_SPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_SPD, 0)

        def VCMPORD_SPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_SPS, 0)

        def VCMPORD_SSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_SSD, 0)

        def VCMPORD_SSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORD_SSS, 0)

        def VCMPORDPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORDPD, 0)

        def VCMPORDPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORDPS, 0)

        def VCMPORDSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORDSD, 0)

        def VCMPORDSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPORDSS, 0)

        def VCMPPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPPD, 0)

        def VCMPPH(self):
            return self.getToken(nasm_x86_64_Parser.VCMPPH, 0)

        def VCMPPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPPS, 0)

        def VCMPSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPSD, 0)

        def VCMPSH(self):
            return self.getToken(nasm_x86_64_Parser.VCMPSH, 0)

        def VCMPSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPSS, 0)

        def VCMPTRUE_UQPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_UQPD, 0)

        def VCMPTRUE_UQPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_UQPS, 0)

        def VCMPTRUE_UQSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_UQSD, 0)

        def VCMPTRUE_UQSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_UQSS, 0)

        def VCMPTRUE_USPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_USPD, 0)

        def VCMPTRUE_USPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_USPS, 0)

        def VCMPTRUE_USSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_USSD, 0)

        def VCMPTRUE_USSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUE_USSS, 0)

        def VCMPTRUEPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUEPD, 0)

        def VCMPTRUEPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUEPS, 0)

        def VCMPTRUESD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUESD, 0)

        def VCMPTRUESS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPTRUESS, 0)

        def VCMPUNORD_QPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_QPD, 0)

        def VCMPUNORD_QPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_QPS, 0)

        def VCMPUNORD_QSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_QSD, 0)

        def VCMPUNORD_QSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_QSS, 0)

        def VCMPUNORD_SPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_SPD, 0)

        def VCMPUNORD_SPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_SPS, 0)

        def VCMPUNORD_SSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_SSD, 0)

        def VCMPUNORD_SSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORD_SSS, 0)

        def VCMPUNORDPD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORDPD, 0)

        def VCMPUNORDPS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORDPS, 0)

        def VCMPUNORDSD(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORDSD, 0)

        def VCMPUNORDSS(self):
            return self.getToken(nasm_x86_64_Parser.VCMPUNORDSS, 0)

        def VCOMISD(self):
            return self.getToken(nasm_x86_64_Parser.VCOMISD, 0)

        def VCOMISH(self):
            return self.getToken(nasm_x86_64_Parser.VCOMISH, 0)

        def VCOMISS(self):
            return self.getToken(nasm_x86_64_Parser.VCOMISS, 0)

        def VCOMPRESSPD(self):
            return self.getToken(nasm_x86_64_Parser.VCOMPRESSPD, 0)

        def VCOMPRESSPS(self):
            return self.getToken(nasm_x86_64_Parser.VCOMPRESSPS, 0)

        def VCVTDQ2PD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTDQ2PD, 0)

        def VCVTDQ2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTDQ2PH, 0)

        def VCVTDQ2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTDQ2PS, 0)

        def VCVTNE2PS2BF16(self):
            return self.getToken(nasm_x86_64_Parser.VCVTNE2PS2BF16, 0)

        def VCVTNEEBF162PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTNEEBF162PS, 0)

        def VCVTNEEPH2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTNEEPH2PS, 0)

        def VCVTNEOBF162PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTNEOBF162PS, 0)

        def VCVTNEOPH2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTNEOPH2PS, 0)

        def VCVTNEPS2BF16(self):
            return self.getToken(nasm_x86_64_Parser.VCVTNEPS2BF16, 0)

        def VCVTPD2DQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPD2DQ, 0)

        def VCVTPD2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPD2PH, 0)

        def VCVTPD2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPD2PS, 0)

        def VCVTPD2QQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPD2QQ, 0)

        def VCVTPD2UDQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPD2UDQ, 0)

        def VCVTPD2UQQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPD2UQQ, 0)

        def VCVTPH2DQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2DQ, 0)

        def VCVTPH2PD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2PD, 0)

        def VCVTPH2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2PS, 0)

        def VCVTPH2PSX(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2PSX, 0)

        def VCVTPH2QQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2QQ, 0)

        def VCVTPH2UDQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2UDQ, 0)

        def VCVTPH2UQQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2UQQ, 0)

        def VCVTPH2UW(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2UW, 0)

        def VCVTPH2W(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPH2W, 0)

        def VCVTPS2DQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPS2DQ, 0)

        def VCVTPS2PD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPS2PD, 0)

        def VCVTPS2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPS2PH, 0)

        def VCVTPS2QQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPS2QQ, 0)

        def VCVTPS2UDQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPS2UDQ, 0)

        def VCVTPS2UQQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTPS2UQQ, 0)

        def VCVTQQ2PD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTQQ2PD, 0)

        def VCVTQQ2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTQQ2PH, 0)

        def VCVTQQ2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTQQ2PS, 0)

        def VCVTSD2SH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSD2SH, 0)

        def VCVTSD2SI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSD2SI, 0)

        def VCVTSD2SS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSD2SS, 0)

        def VCVTSD2USI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSD2USI, 0)

        def VCVTSH2SD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSH2SD, 0)

        def VCVTSH2SI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSH2SI, 0)

        def VCVTSH2SS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSH2SS, 0)

        def VCVTSH2USI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSH2USI, 0)

        def VCVTSI2SD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSI2SD, 0)

        def VCVTSI2SH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSI2SH, 0)

        def VCVTSI2SS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSI2SS, 0)

        def VCVTSS2SD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSS2SD, 0)

        def VCVTSS2SH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSS2SH, 0)

        def VCVTSS2SI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSS2SI, 0)

        def VCVTSS2USI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTSS2USI, 0)

        def VCVTTPD2DQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPD2DQ, 0)

        def VCVTTPD2QQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPD2QQ, 0)

        def VCVTTPD2UDQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPD2UDQ, 0)

        def VCVTTPD2UQQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPD2UQQ, 0)

        def VCVTTPH2DQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPH2DQ, 0)

        def VCVTTPH2QQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPH2QQ, 0)

        def VCVTTPH2UDQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPH2UDQ, 0)

        def VCVTTPH2UQQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPH2UQQ, 0)

        def VCVTTPH2UW(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPH2UW, 0)

        def VCVTTPH2W(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPH2W, 0)

        def VCVTTPS2DQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPS2DQ, 0)

        def VCVTTPS2QQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPS2QQ, 0)

        def VCVTTPS2UDQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPS2UDQ, 0)

        def VCVTTPS2UQQ(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTPS2UQQ, 0)

        def VCVTTSD2SI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTSD2SI, 0)

        def VCVTTSD2USI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTSD2USI, 0)

        def VCVTTSH2SI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTSH2SI, 0)

        def VCVTTSH2USI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTSH2USI, 0)

        def VCVTTSS2SI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTSS2SI, 0)

        def VCVTTSS2USI(self):
            return self.getToken(nasm_x86_64_Parser.VCVTTSS2USI, 0)

        def VCVTUDQ2PD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUDQ2PD, 0)

        def VCVTUDQ2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUDQ2PH, 0)

        def VCVTUDQ2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUDQ2PS, 0)

        def VCVTUQQ2PD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUQQ2PD, 0)

        def VCVTUQQ2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUQQ2PH, 0)

        def VCVTUQQ2PS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUQQ2PS, 0)

        def VCVTUSI2SD(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUSI2SD, 0)

        def VCVTUSI2SH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUSI2SH, 0)

        def VCVTUSI2SS(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUSI2SS, 0)

        def VCVTUW2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTUW2PH, 0)

        def VCVTW2PH(self):
            return self.getToken(nasm_x86_64_Parser.VCVTW2PH, 0)

        def VDBPSADBW(self):
            return self.getToken(nasm_x86_64_Parser.VDBPSADBW, 0)

        def VDIVPD(self):
            return self.getToken(nasm_x86_64_Parser.VDIVPD, 0)

        def VDIVPH(self):
            return self.getToken(nasm_x86_64_Parser.VDIVPH, 0)

        def VDIVPS(self):
            return self.getToken(nasm_x86_64_Parser.VDIVPS, 0)

        def VDIVSD(self):
            return self.getToken(nasm_x86_64_Parser.VDIVSD, 0)

        def VDIVSH(self):
            return self.getToken(nasm_x86_64_Parser.VDIVSH, 0)

        def VDIVSS(self):
            return self.getToken(nasm_x86_64_Parser.VDIVSS, 0)

        def VDPBF16PS(self):
            return self.getToken(nasm_x86_64_Parser.VDPBF16PS, 0)

        def VDPPD(self):
            return self.getToken(nasm_x86_64_Parser.VDPPD, 0)

        def VDPPS(self):
            return self.getToken(nasm_x86_64_Parser.VDPPS, 0)

        def VENDSCALEPH(self):
            return self.getToken(nasm_x86_64_Parser.VENDSCALEPH, 0)

        def VENDSCALESH(self):
            return self.getToken(nasm_x86_64_Parser.VENDSCALESH, 0)

        def VEXP2PD(self):
            return self.getToken(nasm_x86_64_Parser.VEXP2PD, 0)

        def VEXP2PS(self):
            return self.getToken(nasm_x86_64_Parser.VEXP2PS, 0)

        def VEXPANDPD(self):
            return self.getToken(nasm_x86_64_Parser.VEXPANDPD, 0)

        def VEXPANDPS(self):
            return self.getToken(nasm_x86_64_Parser.VEXPANDPS, 0)

        def VEXTRACTF128(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTF128, 0)

        def VEXTRACTF32X4(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTF32X4, 0)

        def VEXTRACTF32X8(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTF32X8, 0)

        def VEXTRACTF64X2(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTF64X2, 0)

        def VEXTRACTF64X4(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTF64X4, 0)

        def VEXTRACTI128(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTI128, 0)

        def VEXTRACTI32X4(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTI32X4, 0)

        def VEXTRACTI32X8(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTI32X8, 0)

        def VEXTRACTI64X2(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTI64X2, 0)

        def VEXTRACTI64X4(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTI64X4, 0)

        def VEXTRACTPS(self):
            return self.getToken(nasm_x86_64_Parser.VEXTRACTPS, 0)

        def VFCMADDCPH(self):
            return self.getToken(nasm_x86_64_Parser.VFCMADDCPH, 0)

        def VFCMADDCSH(self):
            return self.getToken(nasm_x86_64_Parser.VFCMADDCSH, 0)

        def VFCMULCPCH(self):
            return self.getToken(nasm_x86_64_Parser.VFCMULCPCH, 0)

        def VFCMULCSH(self):
            return self.getToken(nasm_x86_64_Parser.VFCMULCSH, 0)

        def VFIXUPIMMPD(self):
            return self.getToken(nasm_x86_64_Parser.VFIXUPIMMPD, 0)

        def VFIXUPIMMPS(self):
            return self.getToken(nasm_x86_64_Parser.VFIXUPIMMPS, 0)

        def VFIXUPIMMSD(self):
            return self.getToken(nasm_x86_64_Parser.VFIXUPIMMSD, 0)

        def VFIXUPIMMSS(self):
            return self.getToken(nasm_x86_64_Parser.VFIXUPIMMSS, 0)

        def VFMADD123PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD123PD, 0)

        def VFMADD123PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD123PS, 0)

        def VFMADD123SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD123SD, 0)

        def VFMADD123SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD123SS, 0)

        def VFMADD132PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD132PD, 0)

        def VFMADD132PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD132PH, 0)

        def VFMADD132PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD132PS, 0)

        def VFMADD132SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD132SD, 0)

        def VFMADD132SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD132SS, 0)

        def VFMADD213PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD213PD, 0)

        def VFMADD213PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD213PH, 0)

        def VFMADD213PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD213PS, 0)

        def VFMADD213SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD213SD, 0)

        def VFMADD213SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD213SS, 0)

        def VFMADD231PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD231PD, 0)

        def VFMADD231PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD231PH, 0)

        def VFMADD231PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD231PS, 0)

        def VFMADD231SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD231SD, 0)

        def VFMADD231SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD231SS, 0)

        def VFMADD312PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD312PD, 0)

        def VFMADD312PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD312PS, 0)

        def VFMADD312SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD312SD, 0)

        def VFMADD312SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD312SS, 0)

        def VFMADD321PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD321PD, 0)

        def VFMADD321PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD321PS, 0)

        def VFMADD321SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD321SD, 0)

        def VFMADD321SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADD321SS, 0)

        def VFMADDCPH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDCPH, 0)

        def VFMADDCSH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDCSH, 0)

        def VFMADDPD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDPD, 0)

        def VFMADDPS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDPS, 0)

        def VFMADDSD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSD, 0)

        def VFMADDSS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSS, 0)

        def VFMADDSUB123PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB123PD, 0)

        def VFMADDSUB123PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB123PS, 0)

        def VFMADDSUB132PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB132PD, 0)

        def VFMADDSUB132PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB132PH, 0)

        def VFMADDSUB132PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB132PS, 0)

        def VFMADDSUB213PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB213PD, 0)

        def VFMADDSUB213PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB213PH, 0)

        def VFMADDSUB213PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB213PS, 0)

        def VFMADDSUB231PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB231PD, 0)

        def VFMADDSUB231PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB231PH, 0)

        def VFMADDSUB231PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB231PS, 0)

        def VFMADDSUB312PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB312PD, 0)

        def VFMADDSUB312PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB312PS, 0)

        def VFMADDSUB321PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB321PD, 0)

        def VFMADDSUB321PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUB321PS, 0)

        def VFMADDSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUBPD, 0)

        def VFMADDSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.VFMADDSUBPS, 0)

        def VFMSUB123PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB123PD, 0)

        def VFMSUB123PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB123PS, 0)

        def VFMSUB123SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB123SD, 0)

        def VFMSUB123SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB123SS, 0)

        def VFMSUB132PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB132PD, 0)

        def VFMSUB132PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB132PH, 0)

        def VFMSUB132PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB132PS, 0)

        def VFMSUB132SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB132SD, 0)

        def VFMSUB132SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB132SS, 0)

        def VFMSUB213PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB213PD, 0)

        def VFMSUB213PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB213PH, 0)

        def VFMSUB213PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB213PS, 0)

        def VFMSUB213SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB213SD, 0)

        def VFMSUB213SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB213SS, 0)

        def VFMSUB231PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB231PD, 0)

        def VFMSUB231PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB231PH, 0)

        def VFMSUB231PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB231PS, 0)

        def VFMSUB231SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB231SD, 0)

        def VFMSUB231SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB231SS, 0)

        def VFMSUB312PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB312PD, 0)

        def VFMSUB312PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB312PS, 0)

        def VFMSUB312SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB312SD, 0)

        def VFMSUB312SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB312SS, 0)

        def VFMSUB321PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB321PD, 0)

        def VFMSUB321PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB321PS, 0)

        def VFMSUB321SD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB321SD, 0)

        def VFMSUB321SS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUB321SS, 0)

        def VFMSUBADD123PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD123PD, 0)

        def VFMSUBADD123PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD123PS, 0)

        def VFMSUBADD132PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD132PD, 0)

        def VFMSUBADD132PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD132PH, 0)

        def VFMSUBADD132PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD132PS, 0)

        def VFMSUBADD213PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD213PD, 0)

        def VFMSUBADD213PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD213PH, 0)

        def VFMSUBADD213PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD213PS, 0)

        def VFMSUBADD231PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD231PD, 0)

        def VFMSUBADD231PH(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD231PH, 0)

        def VFMSUBADD231PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD231PS, 0)

        def VFMSUBADD312PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD312PD, 0)

        def VFMSUBADD312PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD312PS, 0)

        def VFMSUBADD321PD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD321PD, 0)

        def VFMSUBADD321PS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADD321PS, 0)

        def VFMSUBADDPD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADDPD, 0)

        def VFMSUBADDPS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBADDPS, 0)

        def VFMSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBPD, 0)

        def VFMSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBPS, 0)

        def VFMSUBSD(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBSD, 0)

        def VFMSUBSS(self):
            return self.getToken(nasm_x86_64_Parser.VFMSUBSS, 0)

        def VFMULCPCH(self):
            return self.getToken(nasm_x86_64_Parser.VFMULCPCH, 0)

        def VFMULCSH(self):
            return self.getToken(nasm_x86_64_Parser.VFMULCSH, 0)

        def VFNMADD123PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD123PD, 0)

        def VFNMADD123PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD123PS, 0)

        def VFNMADD123SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD123SD, 0)

        def VFNMADD123SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD123SS, 0)

        def VFNMADD132PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD132PD, 0)

        def VFNMADD132PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD132PS, 0)

        def VFNMADD132SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD132SD, 0)

        def VFNMADD132SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD132SS, 0)

        def VFNMADD213PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD213PD, 0)

        def VFNMADD213PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD213PS, 0)

        def VFNMADD213SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD213SD, 0)

        def VFNMADD213SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD213SS, 0)

        def VFNMADD231PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD231PD, 0)

        def VFNMADD231PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD231PS, 0)

        def VFNMADD231SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD231SD, 0)

        def VFNMADD231SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD231SS, 0)

        def VFNMADD312PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD312PD, 0)

        def VFNMADD312PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD312PS, 0)

        def VFNMADD312SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD312SD, 0)

        def VFNMADD312SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD312SS, 0)

        def VFNMADD321PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD321PD, 0)

        def VFNMADD321PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD321PS, 0)

        def VFNMADD321SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD321SD, 0)

        def VFNMADD321SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADD321SS, 0)

        def VFNMADDPD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADDPD, 0)

        def VFNMADDPS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADDPS, 0)

        def VFNMADDSD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADDSD, 0)

        def VFNMADDSS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMADDSS, 0)

        def VFNMSUB123PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB123PD, 0)

        def VFNMSUB123PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB123PS, 0)

        def VFNMSUB123SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB123SD, 0)

        def VFNMSUB123SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB123SS, 0)

        def VFNMSUB132PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB132PD, 0)

        def VFNMSUB132PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB132PS, 0)

        def VFNMSUB132SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB132SD, 0)

        def VFNMSUB132SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB132SS, 0)

        def VFNMSUB213PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB213PD, 0)

        def VFNMSUB213PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB213PS, 0)

        def VFNMSUB213SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB213SD, 0)

        def VFNMSUB213SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB213SS, 0)

        def VFNMSUB231PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB231PD, 0)

        def VFNMSUB231PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB231PS, 0)

        def VFNMSUB231SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB231SD, 0)

        def VFNMSUB231SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB231SS, 0)

        def VFNMSUB312PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB312PD, 0)

        def VFNMSUB312PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB312PS, 0)

        def VFNMSUB312SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB312SD, 0)

        def VFNMSUB312SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB312SS, 0)

        def VFNMSUB321PD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB321PD, 0)

        def VFNMSUB321PS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB321PS, 0)

        def VFNMSUB321SD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB321SD, 0)

        def VFNMSUB321SS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUB321SS, 0)

        def VFNMSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUBPD, 0)

        def VFNMSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUBPS, 0)

        def VFNMSUBSD(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUBSD, 0)

        def VFNMSUBSS(self):
            return self.getToken(nasm_x86_64_Parser.VFNMSUBSS, 0)

        def VFPCLASSPD(self):
            return self.getToken(nasm_x86_64_Parser.VFPCLASSPD, 0)

        def VFPCLASSPH(self):
            return self.getToken(nasm_x86_64_Parser.VFPCLASSPH, 0)

        def VFPCLASSPS(self):
            return self.getToken(nasm_x86_64_Parser.VFPCLASSPS, 0)

        def VFPCLASSSD(self):
            return self.getToken(nasm_x86_64_Parser.VFPCLASSSD, 0)

        def VFPCLASSSH(self):
            return self.getToken(nasm_x86_64_Parser.VFPCLASSSH, 0)

        def VFPCLASSSS(self):
            return self.getToken(nasm_x86_64_Parser.VFPCLASSSS, 0)

        def VFRCZPD(self):
            return self.getToken(nasm_x86_64_Parser.VFRCZPD, 0)

        def VFRCZPS(self):
            return self.getToken(nasm_x86_64_Parser.VFRCZPS, 0)

        def VFRCZSD(self):
            return self.getToken(nasm_x86_64_Parser.VFRCZSD, 0)

        def VFRCZSS(self):
            return self.getToken(nasm_x86_64_Parser.VFRCZSS, 0)

        def VGATHERDPD(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERDPD, 0)

        def VGATHERDPS(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERDPS, 0)

        def VGATHERPF0DPD(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF0DPD, 0)

        def VGATHERPF0DPS(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF0DPS, 0)

        def VGATHERPF0QPD(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF0QPD, 0)

        def VGATHERPF0QPS(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF0QPS, 0)

        def VGATHERPF1DPD(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF1DPD, 0)

        def VGATHERPF1DPS(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF1DPS, 0)

        def VGATHERPF1QPD(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF1QPD, 0)

        def VGATHERPF1QPS(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERPF1QPS, 0)

        def VGATHERQPD(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERQPD, 0)

        def VGATHERQPS(self):
            return self.getToken(nasm_x86_64_Parser.VGATHERQPS, 0)

        def VGETEXPPD(self):
            return self.getToken(nasm_x86_64_Parser.VGETEXPPD, 0)

        def VGETEXPPH(self):
            return self.getToken(nasm_x86_64_Parser.VGETEXPPH, 0)

        def VGETEXPPS(self):
            return self.getToken(nasm_x86_64_Parser.VGETEXPPS, 0)

        def VGETEXPSD(self):
            return self.getToken(nasm_x86_64_Parser.VGETEXPSD, 0)

        def VGETEXPSH(self):
            return self.getToken(nasm_x86_64_Parser.VGETEXPSH, 0)

        def VGETEXPSS(self):
            return self.getToken(nasm_x86_64_Parser.VGETEXPSS, 0)

        def VGETMANTPD(self):
            return self.getToken(nasm_x86_64_Parser.VGETMANTPD, 0)

        def VGETMANTPH(self):
            return self.getToken(nasm_x86_64_Parser.VGETMANTPH, 0)

        def VGETMANTPS(self):
            return self.getToken(nasm_x86_64_Parser.VGETMANTPS, 0)

        def VGETMANTSD(self):
            return self.getToken(nasm_x86_64_Parser.VGETMANTSD, 0)

        def VGETMANTSH(self):
            return self.getToken(nasm_x86_64_Parser.VGETMANTSH, 0)

        def VGETMANTSS(self):
            return self.getToken(nasm_x86_64_Parser.VGETMANTSS, 0)

        def VGETMAXPH(self):
            return self.getToken(nasm_x86_64_Parser.VGETMAXPH, 0)

        def VGETMAXSH(self):
            return self.getToken(nasm_x86_64_Parser.VGETMAXSH, 0)

        def VGETMINPH(self):
            return self.getToken(nasm_x86_64_Parser.VGETMINPH, 0)

        def VGETMINSH(self):
            return self.getToken(nasm_x86_64_Parser.VGETMINSH, 0)

        def VGF2P8AFFINEINVQB(self):
            return self.getToken(nasm_x86_64_Parser.VGF2P8AFFINEINVQB, 0)

        def VGF2P8AFFINEQB(self):
            return self.getToken(nasm_x86_64_Parser.VGF2P8AFFINEQB, 0)

        def VGF2P8MULB(self):
            return self.getToken(nasm_x86_64_Parser.VGF2P8MULB, 0)

        def VHADDPD(self):
            return self.getToken(nasm_x86_64_Parser.VHADDPD, 0)

        def VHADDPS(self):
            return self.getToken(nasm_x86_64_Parser.VHADDPS, 0)

        def VHSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.VHSUBPD, 0)

        def VHSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.VHSUBPS, 0)

        def VINSERTF128(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTF128, 0)

        def VINSERTF32X4(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTF32X4, 0)

        def VINSERTF32X8(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTF32X8, 0)

        def VINSERTF64X2(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTF64X2, 0)

        def VINSERTF64X4(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTF64X4, 0)

        def VINSERTI128(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTI128, 0)

        def VINSERTI32X4(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTI32X4, 0)

        def VINSERTI32X8(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTI32X8, 0)

        def VINSERTI64X2(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTI64X2, 0)

        def VINSERTI64X4(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTI64X4, 0)

        def VINSERTPS(self):
            return self.getToken(nasm_x86_64_Parser.VINSERTPS, 0)

        def VLDDQU(self):
            return self.getToken(nasm_x86_64_Parser.VLDDQU, 0)

        def VLDMXCSR(self):
            return self.getToken(nasm_x86_64_Parser.VLDMXCSR, 0)

        def VLDQQU(self):
            return self.getToken(nasm_x86_64_Parser.VLDQQU, 0)

        def VMASKMOVDQU(self):
            return self.getToken(nasm_x86_64_Parser.VMASKMOVDQU, 0)

        def VMASKMOVPD(self):
            return self.getToken(nasm_x86_64_Parser.VMASKMOVPD, 0)

        def VMASKMOVPS(self):
            return self.getToken(nasm_x86_64_Parser.VMASKMOVPS, 0)

        def VMAXPD(self):
            return self.getToken(nasm_x86_64_Parser.VMAXPD, 0)

        def VMAXPS(self):
            return self.getToken(nasm_x86_64_Parser.VMAXPS, 0)

        def VMAXSD(self):
            return self.getToken(nasm_x86_64_Parser.VMAXSD, 0)

        def VMAXSS(self):
            return self.getToken(nasm_x86_64_Parser.VMAXSS, 0)

        def VMCALL(self):
            return self.getToken(nasm_x86_64_Parser.VMCALL, 0)

        def VMCLEAR(self):
            return self.getToken(nasm_x86_64_Parser.VMCLEAR, 0)

        def VMFUNC(self):
            return self.getToken(nasm_x86_64_Parser.VMFUNC, 0)

        def VMGEXIT(self):
            return self.getToken(nasm_x86_64_Parser.VMGEXIT, 0)

        def VMINPD(self):
            return self.getToken(nasm_x86_64_Parser.VMINPD, 0)

        def VMINPS(self):
            return self.getToken(nasm_x86_64_Parser.VMINPS, 0)

        def VMINSD(self):
            return self.getToken(nasm_x86_64_Parser.VMINSD, 0)

        def VMINSS(self):
            return self.getToken(nasm_x86_64_Parser.VMINSS, 0)

        def VMLAUNCH(self):
            return self.getToken(nasm_x86_64_Parser.VMLAUNCH, 0)

        def VMLOAD(self):
            return self.getToken(nasm_x86_64_Parser.VMLOAD, 0)

        def VMMCALL(self):
            return self.getToken(nasm_x86_64_Parser.VMMCALL, 0)

        def VMOVAPD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVAPD, 0)

        def VMOVAPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVAPS, 0)

        def VMOVD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVD, 0)

        def VMOVDDUP(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDDUP, 0)

        def VMOVDQA(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQA, 0)

        def VMOVDQA32(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQA32, 0)

        def VMOVDQA64(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQA64, 0)

        def VMOVDQU(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQU, 0)

        def VMOVDQU16(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQU16, 0)

        def VMOVDQU32(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQU32, 0)

        def VMOVDQU64(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQU64, 0)

        def VMOVDQU8(self):
            return self.getToken(nasm_x86_64_Parser.VMOVDQU8, 0)

        def VMOVHLPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVHLPS, 0)

        def VMOVHPD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVHPD, 0)

        def VMOVHPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVHPS, 0)

        def VMOVLHPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVLHPS, 0)

        def VMOVLPD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVLPD, 0)

        def VMOVLPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVLPS, 0)

        def VMOVMSKPD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVMSKPD, 0)

        def VMOVMSKPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVMSKPS, 0)

        def VMOVNTDQ(self):
            return self.getToken(nasm_x86_64_Parser.VMOVNTDQ, 0)

        def VMOVNTDQA(self):
            return self.getToken(nasm_x86_64_Parser.VMOVNTDQA, 0)

        def VMOVNTPD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVNTPD, 0)

        def VMOVNTPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVNTPS, 0)

        def VMOVNTQQ(self):
            return self.getToken(nasm_x86_64_Parser.VMOVNTQQ, 0)

        def VMOVQ(self):
            return self.getToken(nasm_x86_64_Parser.VMOVQ, 0)

        def VMOVQQA(self):
            return self.getToken(nasm_x86_64_Parser.VMOVQQA, 0)

        def VMOVQQU(self):
            return self.getToken(nasm_x86_64_Parser.VMOVQQU, 0)

        def VMOVSD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVSD, 0)

        def VMOVSH(self):
            return self.getToken(nasm_x86_64_Parser.VMOVSH, 0)

        def VMOVSHDUP(self):
            return self.getToken(nasm_x86_64_Parser.VMOVSHDUP, 0)

        def VMOVSLDUP(self):
            return self.getToken(nasm_x86_64_Parser.VMOVSLDUP, 0)

        def VMOVSS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVSS, 0)

        def VMOVUPD(self):
            return self.getToken(nasm_x86_64_Parser.VMOVUPD, 0)

        def VMOVUPS(self):
            return self.getToken(nasm_x86_64_Parser.VMOVUPS, 0)

        def VMOVW(self):
            return self.getToken(nasm_x86_64_Parser.VMOVW, 0)

        def VMPSADBW(self):
            return self.getToken(nasm_x86_64_Parser.VMPSADBW, 0)

        def VMPTRLD(self):
            return self.getToken(nasm_x86_64_Parser.VMPTRLD, 0)

        def VMPTRST(self):
            return self.getToken(nasm_x86_64_Parser.VMPTRST, 0)

        def VMREAD(self):
            return self.getToken(nasm_x86_64_Parser.VMREAD, 0)

        def VMRESUME(self):
            return self.getToken(nasm_x86_64_Parser.VMRESUME, 0)

        def VMRUN(self):
            return self.getToken(nasm_x86_64_Parser.VMRUN, 0)

        def VMSAVE(self):
            return self.getToken(nasm_x86_64_Parser.VMSAVE, 0)

        def VMULPD(self):
            return self.getToken(nasm_x86_64_Parser.VMULPD, 0)

        def VMULPH(self):
            return self.getToken(nasm_x86_64_Parser.VMULPH, 0)

        def VMULPS(self):
            return self.getToken(nasm_x86_64_Parser.VMULPS, 0)

        def VMULSD(self):
            return self.getToken(nasm_x86_64_Parser.VMULSD, 0)

        def VMULSH(self):
            return self.getToken(nasm_x86_64_Parser.VMULSH, 0)

        def VMULSS(self):
            return self.getToken(nasm_x86_64_Parser.VMULSS, 0)

        def VMWRITE(self):
            return self.getToken(nasm_x86_64_Parser.VMWRITE, 0)

        def VMXOFF(self):
            return self.getToken(nasm_x86_64_Parser.VMXOFF, 0)

        def VMXON(self):
            return self.getToken(nasm_x86_64_Parser.VMXON, 0)

        def VORPD(self):
            return self.getToken(nasm_x86_64_Parser.VORPD, 0)

        def VORPS(self):
            return self.getToken(nasm_x86_64_Parser.VORPS, 0)

        def VP2INTERSECTD(self):
            return self.getToken(nasm_x86_64_Parser.VP2INTERSECTD, 0)

        def VPABSB(self):
            return self.getToken(nasm_x86_64_Parser.VPABSB, 0)

        def VPABSD(self):
            return self.getToken(nasm_x86_64_Parser.VPABSD, 0)

        def VPABSQ(self):
            return self.getToken(nasm_x86_64_Parser.VPABSQ, 0)

        def VPABSW(self):
            return self.getToken(nasm_x86_64_Parser.VPABSW, 0)

        def VPACKSSDW(self):
            return self.getToken(nasm_x86_64_Parser.VPACKSSDW, 0)

        def VPACKSSWB(self):
            return self.getToken(nasm_x86_64_Parser.VPACKSSWB, 0)

        def VPACKUSDW(self):
            return self.getToken(nasm_x86_64_Parser.VPACKUSDW, 0)

        def VPACKUSWB(self):
            return self.getToken(nasm_x86_64_Parser.VPACKUSWB, 0)

        def VPADDB(self):
            return self.getToken(nasm_x86_64_Parser.VPADDB, 0)

        def VPADDD(self):
            return self.getToken(nasm_x86_64_Parser.VPADDD, 0)

        def VPADDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPADDQ, 0)

        def VPADDSB(self):
            return self.getToken(nasm_x86_64_Parser.VPADDSB, 0)

        def VPADDSW(self):
            return self.getToken(nasm_x86_64_Parser.VPADDSW, 0)

        def VPADDUSB(self):
            return self.getToken(nasm_x86_64_Parser.VPADDUSB, 0)

        def VPADDUSW(self):
            return self.getToken(nasm_x86_64_Parser.VPADDUSW, 0)

        def VPADDW(self):
            return self.getToken(nasm_x86_64_Parser.VPADDW, 0)

        def VPALIGNR(self):
            return self.getToken(nasm_x86_64_Parser.VPALIGNR, 0)

        def VPAND(self):
            return self.getToken(nasm_x86_64_Parser.VPAND, 0)

        def VPANDD(self):
            return self.getToken(nasm_x86_64_Parser.VPANDD, 0)

        def VPANDN(self):
            return self.getToken(nasm_x86_64_Parser.VPANDN, 0)

        def VPANDND(self):
            return self.getToken(nasm_x86_64_Parser.VPANDND, 0)

        def VPANDNQ(self):
            return self.getToken(nasm_x86_64_Parser.VPANDNQ, 0)

        def VPANDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPANDQ, 0)

        def VPAVGB(self):
            return self.getToken(nasm_x86_64_Parser.VPAVGB, 0)

        def VPAVGW(self):
            return self.getToken(nasm_x86_64_Parser.VPAVGW, 0)

        def VPBLENDD(self):
            return self.getToken(nasm_x86_64_Parser.VPBLENDD, 0)

        def VPBLENDMB(self):
            return self.getToken(nasm_x86_64_Parser.VPBLENDMB, 0)

        def VPBLENDMD(self):
            return self.getToken(nasm_x86_64_Parser.VPBLENDMD, 0)

        def VPBLENDMQ(self):
            return self.getToken(nasm_x86_64_Parser.VPBLENDMQ, 0)

        def VPBLENDMW(self):
            return self.getToken(nasm_x86_64_Parser.VPBLENDMW, 0)

        def VPBLENDVB(self):
            return self.getToken(nasm_x86_64_Parser.VPBLENDVB, 0)

        def VPBLENDW(self):
            return self.getToken(nasm_x86_64_Parser.VPBLENDW, 0)

        def VPBROADCASTB(self):
            return self.getToken(nasm_x86_64_Parser.VPBROADCASTB, 0)

        def VPBROADCASTD(self):
            return self.getToken(nasm_x86_64_Parser.VPBROADCASTD, 0)

        def VPBROADCASTMB2Q(self):
            return self.getToken(nasm_x86_64_Parser.VPBROADCASTMB2Q, 0)

        def VPBROADCASTMW2D(self):
            return self.getToken(nasm_x86_64_Parser.VPBROADCASTMW2D, 0)

        def VPBROADCASTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPBROADCASTQ, 0)

        def VPBROADCASTW(self):
            return self.getToken(nasm_x86_64_Parser.VPBROADCASTW, 0)

        def VPCLMULHQHQDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCLMULHQHQDQ, 0)

        def VPCLMULHQLQDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCLMULHQLQDQ, 0)

        def VPCLMULLQHQDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCLMULLQHQDQ, 0)

        def VPCLMULLQLQDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCLMULLQLQDQ, 0)

        def VPCLMULQDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCLMULQDQ, 0)

        def VPCMOV(self):
            return self.getToken(nasm_x86_64_Parser.VPCMOV, 0)

        def VPCMPB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPB, 0)

        def VPCMPD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPD, 0)

        def VPCMPEQB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQB, 0)

        def VPCMPEQD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQD, 0)

        def VPCMPEQQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQQ, 0)

        def VPCMPEQUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQUB, 0)

        def VPCMPEQUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQUD, 0)

        def VPCMPEQUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQUQ, 0)

        def VPCMPEQUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQUW, 0)

        def VPCMPEQW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPEQW, 0)

        def VPCMPESTRI(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPESTRI, 0)

        def VPCMPESTRM(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPESTRM, 0)

        def VPCMPGEB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGEB, 0)

        def VPCMPGED(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGED, 0)

        def VPCMPGEQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGEQ, 0)

        def VPCMPGEUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGEUB, 0)

        def VPCMPGEUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGEUD, 0)

        def VPCMPGEUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGEUQ, 0)

        def VPCMPGEUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGEUW, 0)

        def VPCMPGEW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGEW, 0)

        def VPCMPGTB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTB, 0)

        def VPCMPGTD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTD, 0)

        def VPCMPGTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTQ, 0)

        def VPCMPGTUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTUB, 0)

        def VPCMPGTUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTUD, 0)

        def VPCMPGTUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTUQ, 0)

        def VPCMPGTUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTUW, 0)

        def VPCMPGTW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPGTW, 0)

        def VPCMPISTRI(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPISTRI, 0)

        def VPCMPISTRM(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPISTRM, 0)

        def VPCMPLEB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLEB, 0)

        def VPCMPLED(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLED, 0)

        def VPCMPLEQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLEQ, 0)

        def VPCMPLEUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLEUB, 0)

        def VPCMPLEUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLEUD, 0)

        def VPCMPLEUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLEUQ, 0)

        def VPCMPLEUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLEUW, 0)

        def VPCMPLEW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLEW, 0)

        def VPCMPLTB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTB, 0)

        def VPCMPLTD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTD, 0)

        def VPCMPLTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTQ, 0)

        def VPCMPLTUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTUB, 0)

        def VPCMPLTUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTUD, 0)

        def VPCMPLTUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTUQ, 0)

        def VPCMPLTUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTUW, 0)

        def VPCMPLTW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPLTW, 0)

        def VPCMPNEQB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQB, 0)

        def VPCMPNEQD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQD, 0)

        def VPCMPNEQQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQQ, 0)

        def VPCMPNEQUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQUB, 0)

        def VPCMPNEQUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQUD, 0)

        def VPCMPNEQUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQUQ, 0)

        def VPCMPNEQUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQUW, 0)

        def VPCMPNEQW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNEQW, 0)

        def VPCMPNGTB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTB, 0)

        def VPCMPNGTD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTD, 0)

        def VPCMPNGTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTQ, 0)

        def VPCMPNGTUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTUB, 0)

        def VPCMPNGTUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTUD, 0)

        def VPCMPNGTUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTUQ, 0)

        def VPCMPNGTUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTUW, 0)

        def VPCMPNGTW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNGTW, 0)

        def VPCMPNLEB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLEB, 0)

        def VPCMPNLED(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLED, 0)

        def VPCMPNLEQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLEQ, 0)

        def VPCMPNLEUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLEUB, 0)

        def VPCMPNLEUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLEUD, 0)

        def VPCMPNLEUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLEUQ, 0)

        def VPCMPNLEUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLEUW, 0)

        def VPCMPNLEW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLEW, 0)

        def VPCMPNLTB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTB, 0)

        def VPCMPNLTD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTD, 0)

        def VPCMPNLTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTQ, 0)

        def VPCMPNLTUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTUB, 0)

        def VPCMPNLTUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTUD, 0)

        def VPCMPNLTUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTUQ, 0)

        def VPCMPNLTUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTUW, 0)

        def VPCMPNLTW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPNLTW, 0)

        def VPCMPQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPQ, 0)

        def VPCMPUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPUB, 0)

        def VPCMPUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPUD, 0)

        def VPCMPUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPUQ, 0)

        def VPCMPUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPUW, 0)

        def VPCMPW(self):
            return self.getToken(nasm_x86_64_Parser.VPCMPW, 0)

        def VPCOMB(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMB, 0)

        def VPCOMD(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMD, 0)

        def VPCOMPRESSB(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMPRESSB, 0)

        def VPCOMPRESSD(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMPRESSD, 0)

        def VPCOMPRESSQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMPRESSQ, 0)

        def VPCOMPRESSW(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMPRESSW, 0)

        def VPCOMQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMQ, 0)

        def VPCOMUB(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMUB, 0)

        def VPCOMUD(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMUD, 0)

        def VPCOMUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMUQ, 0)

        def VPCOMUW(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMUW, 0)

        def VPCOMW(self):
            return self.getToken(nasm_x86_64_Parser.VPCOMW, 0)

        def VPCONFLICTD(self):
            return self.getToken(nasm_x86_64_Parser.VPCONFLICTD, 0)

        def VPCONFLICTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPCONFLICTQ, 0)

        def VPDPBSSD(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBSSD, 0)

        def VPDPBSSDS(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBSSDS, 0)

        def VPDPBSUD(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBSUD, 0)

        def VPDPBSUDS(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBSUDS, 0)

        def VPDPBUSD(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBUSD, 0)

        def VPDPBUSDS(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBUSDS, 0)

        def VPDPBUUD(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBUUD, 0)

        def VPDPBUUDS(self):
            return self.getToken(nasm_x86_64_Parser.VPDPBUUDS, 0)

        def VPDPWSSD(self):
            return self.getToken(nasm_x86_64_Parser.VPDPWSSD, 0)

        def VPDPWSSDS(self):
            return self.getToken(nasm_x86_64_Parser.VPDPWSSDS, 0)

        def VPERM2F128(self):
            return self.getToken(nasm_x86_64_Parser.VPERM2F128, 0)

        def VPERM2I128(self):
            return self.getToken(nasm_x86_64_Parser.VPERM2I128, 0)

        def VPERMB(self):
            return self.getToken(nasm_x86_64_Parser.VPERMB, 0)

        def VPERMD(self):
            return self.getToken(nasm_x86_64_Parser.VPERMD, 0)

        def VPERMI2B(self):
            return self.getToken(nasm_x86_64_Parser.VPERMI2B, 0)

        def VPERMI2D(self):
            return self.getToken(nasm_x86_64_Parser.VPERMI2D, 0)

        def VPERMI2PD(self):
            return self.getToken(nasm_x86_64_Parser.VPERMI2PD, 0)

        def VPERMI2PS(self):
            return self.getToken(nasm_x86_64_Parser.VPERMI2PS, 0)

        def VPERMI2Q(self):
            return self.getToken(nasm_x86_64_Parser.VPERMI2Q, 0)

        def VPERMI2W(self):
            return self.getToken(nasm_x86_64_Parser.VPERMI2W, 0)

        def VPERMILPD(self):
            return self.getToken(nasm_x86_64_Parser.VPERMILPD, 0)

        def VPERMILPS(self):
            return self.getToken(nasm_x86_64_Parser.VPERMILPS, 0)

        def VPERMPD(self):
            return self.getToken(nasm_x86_64_Parser.VPERMPD, 0)

        def VPERMPS(self):
            return self.getToken(nasm_x86_64_Parser.VPERMPS, 0)

        def VPERMQ(self):
            return self.getToken(nasm_x86_64_Parser.VPERMQ, 0)

        def VPERMT2B(self):
            return self.getToken(nasm_x86_64_Parser.VPERMT2B, 0)

        def VPERMT2D(self):
            return self.getToken(nasm_x86_64_Parser.VPERMT2D, 0)

        def VPERMT2PD(self):
            return self.getToken(nasm_x86_64_Parser.VPERMT2PD, 0)

        def VPERMT2PS(self):
            return self.getToken(nasm_x86_64_Parser.VPERMT2PS, 0)

        def VPERMT2Q(self):
            return self.getToken(nasm_x86_64_Parser.VPERMT2Q, 0)

        def VPERMT2W(self):
            return self.getToken(nasm_x86_64_Parser.VPERMT2W, 0)

        def VPERMW(self):
            return self.getToken(nasm_x86_64_Parser.VPERMW, 0)

        def VPEXPANDB(self):
            return self.getToken(nasm_x86_64_Parser.VPEXPANDB, 0)

        def VPEXPANDD(self):
            return self.getToken(nasm_x86_64_Parser.VPEXPANDD, 0)

        def VPEXPANDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPEXPANDQ, 0)

        def VPEXPANDW(self):
            return self.getToken(nasm_x86_64_Parser.VPEXPANDW, 0)

        def VPEXTRB(self):
            return self.getToken(nasm_x86_64_Parser.VPEXTRB, 0)

        def VPEXTRD(self):
            return self.getToken(nasm_x86_64_Parser.VPEXTRD, 0)

        def VPEXTRQ(self):
            return self.getToken(nasm_x86_64_Parser.VPEXTRQ, 0)

        def VPEXTRW(self):
            return self.getToken(nasm_x86_64_Parser.VPEXTRW, 0)

        def VPGATHERDD(self):
            return self.getToken(nasm_x86_64_Parser.VPGATHERDD, 0)

        def VPGATHERDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPGATHERDQ, 0)

        def VPGATHERQD(self):
            return self.getToken(nasm_x86_64_Parser.VPGATHERQD, 0)

        def VPGATHERQQ(self):
            return self.getToken(nasm_x86_64_Parser.VPGATHERQQ, 0)

        def VPHADDBD(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDBD, 0)

        def VPHADDBQ(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDBQ, 0)

        def VPHADDBW(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDBW, 0)

        def VPHADDD(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDD, 0)

        def VPHADDDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDDQ, 0)

        def VPHADDSW(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDSW, 0)

        def VPHADDUBD(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDUBD, 0)

        def VPHADDUBQ(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDUBQ, 0)

        def VPHADDUBW(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDUBW, 0)

        def VPHADDUDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDUDQ, 0)

        def VPHADDUWD(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDUWD, 0)

        def VPHADDUWQ(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDUWQ, 0)

        def VPHADDW(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDW, 0)

        def VPHADDWD(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDWD, 0)

        def VPHADDWQ(self):
            return self.getToken(nasm_x86_64_Parser.VPHADDWQ, 0)

        def VPHMINPOSUW(self):
            return self.getToken(nasm_x86_64_Parser.VPHMINPOSUW, 0)

        def VPHSUBBW(self):
            return self.getToken(nasm_x86_64_Parser.VPHSUBBW, 0)

        def VPHSUBD(self):
            return self.getToken(nasm_x86_64_Parser.VPHSUBD, 0)

        def VPHSUBDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPHSUBDQ, 0)

        def VPHSUBSW(self):
            return self.getToken(nasm_x86_64_Parser.VPHSUBSW, 0)

        def VPHSUBW(self):
            return self.getToken(nasm_x86_64_Parser.VPHSUBW, 0)

        def VPHSUBWD(self):
            return self.getToken(nasm_x86_64_Parser.VPHSUBWD, 0)

        def VPINSRB(self):
            return self.getToken(nasm_x86_64_Parser.VPINSRB, 0)

        def VPINSRD(self):
            return self.getToken(nasm_x86_64_Parser.VPINSRD, 0)

        def VPINSRQ(self):
            return self.getToken(nasm_x86_64_Parser.VPINSRQ, 0)

        def VPINSRW(self):
            return self.getToken(nasm_x86_64_Parser.VPINSRW, 0)

        def VPLZCNTD(self):
            return self.getToken(nasm_x86_64_Parser.VPLZCNTD, 0)

        def VPLZCNTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPLZCNTQ, 0)

        def VPMACSDD(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSDD, 0)

        def VPMACSDQH(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSDQH, 0)

        def VPMACSDQL(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSDQL, 0)

        def VPMACSSDD(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSSDD, 0)

        def VPMACSSDQH(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSSDQH, 0)

        def VPMACSSDQL(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSSDQL, 0)

        def VPMACSSWD(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSSWD, 0)

        def VPMACSSWW(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSSWW, 0)

        def VPMACSWD(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSWD, 0)

        def VPMACSWW(self):
            return self.getToken(nasm_x86_64_Parser.VPMACSWW, 0)

        def VPMADCSSWD(self):
            return self.getToken(nasm_x86_64_Parser.VPMADCSSWD, 0)

        def VPMADCSWD(self):
            return self.getToken(nasm_x86_64_Parser.VPMADCSWD, 0)

        def VPMADD132PH(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD132PH, 0)

        def VPMADD132SH(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD132SH, 0)

        def VPMADD213PH(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD213PH, 0)

        def VPMADD213SH(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD213SH, 0)

        def VPMADD231PH(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD231PH, 0)

        def VPMADD231SH(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD231SH, 0)

        def VPMADD52HUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD52HUQ, 0)

        def VPMADD52LUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMADD52LUQ, 0)

        def VPMADDUBSW(self):
            return self.getToken(nasm_x86_64_Parser.VPMADDUBSW, 0)

        def VPMADDWD(self):
            return self.getToken(nasm_x86_64_Parser.VPMADDWD, 0)

        def VPMASKMOVD(self):
            return self.getToken(nasm_x86_64_Parser.VPMASKMOVD, 0)

        def VPMASKMOVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMASKMOVQ, 0)

        def VPMAXSB(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXSB, 0)

        def VPMAXSD(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXSD, 0)

        def VPMAXSQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXSQ, 0)

        def VPMAXSW(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXSW, 0)

        def VPMAXUB(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXUB, 0)

        def VPMAXUD(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXUD, 0)

        def VPMAXUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXUQ, 0)

        def VPMAXUW(self):
            return self.getToken(nasm_x86_64_Parser.VPMAXUW, 0)

        def VPMINSB(self):
            return self.getToken(nasm_x86_64_Parser.VPMINSB, 0)

        def VPMINSD(self):
            return self.getToken(nasm_x86_64_Parser.VPMINSD, 0)

        def VPMINSQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMINSQ, 0)

        def VPMINSW(self):
            return self.getToken(nasm_x86_64_Parser.VPMINSW, 0)

        def VPMINUB(self):
            return self.getToken(nasm_x86_64_Parser.VPMINUB, 0)

        def VPMINUD(self):
            return self.getToken(nasm_x86_64_Parser.VPMINUD, 0)

        def VPMINUQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMINUQ, 0)

        def VPMINUW(self):
            return self.getToken(nasm_x86_64_Parser.VPMINUW, 0)

        def VPMOVB2M(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVB2M, 0)

        def VPMOVD2M(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVD2M, 0)

        def VPMOVDB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVDB, 0)

        def VPMOVDW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVDW, 0)

        def VPMOVM2B(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVM2B, 0)

        def VPMOVM2D(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVM2D, 0)

        def VPMOVM2Q(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVM2Q, 0)

        def VPMOVM2W(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVM2W, 0)

        def VPMOVMSKB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVMSKB, 0)

        def VPMOVQ2M(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVQ2M, 0)

        def VPMOVQB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVQB, 0)

        def VPMOVQD(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVQD, 0)

        def VPMOVQW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVQW, 0)

        def VPMOVSDB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSDB, 0)

        def VPMOVSDW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSDW, 0)

        def VPMOVSQB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSQB, 0)

        def VPMOVSQD(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSQD, 0)

        def VPMOVSQW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSQW, 0)

        def VPMOVSWB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSWB, 0)

        def VPMOVSXBD(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSXBD, 0)

        def VPMOVSXBQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSXBQ, 0)

        def VPMOVSXBW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSXBW, 0)

        def VPMOVSXDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSXDQ, 0)

        def VPMOVSXWD(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSXWD, 0)

        def VPMOVSXWQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVSXWQ, 0)

        def VPMOVUSDB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVUSDB, 0)

        def VPMOVUSDW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVUSDW, 0)

        def VPMOVUSQB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVUSQB, 0)

        def VPMOVUSQD(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVUSQD, 0)

        def VPMOVUSQW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVUSQW, 0)

        def VPMOVUSWB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVUSWB, 0)

        def VPMOVW2M(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVW2M, 0)

        def VPMOVWB(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVWB, 0)

        def VPMOVZXBD(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVZXBD, 0)

        def VPMOVZXBQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVZXBQ, 0)

        def VPMOVZXBW(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVZXBW, 0)

        def VPMOVZXDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVZXDQ, 0)

        def VPMOVZXWD(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVZXWD, 0)

        def VPMOVZXWQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMOVZXWQ, 0)

        def VPMSUB132PH(self):
            return self.getToken(nasm_x86_64_Parser.VPMSUB132PH, 0)

        def VPMSUB132SH(self):
            return self.getToken(nasm_x86_64_Parser.VPMSUB132SH, 0)

        def VPMSUB213PH(self):
            return self.getToken(nasm_x86_64_Parser.VPMSUB213PH, 0)

        def VPMSUB213SH(self):
            return self.getToken(nasm_x86_64_Parser.VPMSUB213SH, 0)

        def VPMSUB231PH(self):
            return self.getToken(nasm_x86_64_Parser.VPMSUB231PH, 0)

        def VPMSUB231SH(self):
            return self.getToken(nasm_x86_64_Parser.VPMSUB231SH, 0)

        def VPMULDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMULDQ, 0)

        def VPMULHRSW(self):
            return self.getToken(nasm_x86_64_Parser.VPMULHRSW, 0)

        def VPMULHUW(self):
            return self.getToken(nasm_x86_64_Parser.VPMULHUW, 0)

        def VPMULHW(self):
            return self.getToken(nasm_x86_64_Parser.VPMULHW, 0)

        def VPMULLD(self):
            return self.getToken(nasm_x86_64_Parser.VPMULLD, 0)

        def VPMULLQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMULLQ, 0)

        def VPMULLW(self):
            return self.getToken(nasm_x86_64_Parser.VPMULLW, 0)

        def VPMULTISHIFTQB(self):
            return self.getToken(nasm_x86_64_Parser.VPMULTISHIFTQB, 0)

        def VPMULUDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPMULUDQ, 0)

        def VPNMADD132SH(self):
            return self.getToken(nasm_x86_64_Parser.VPNMADD132SH, 0)

        def VPNMADD213SH(self):
            return self.getToken(nasm_x86_64_Parser.VPNMADD213SH, 0)

        def VPNMADD231SH(self):
            return self.getToken(nasm_x86_64_Parser.VPNMADD231SH, 0)

        def VPNMSUB132SH(self):
            return self.getToken(nasm_x86_64_Parser.VPNMSUB132SH, 0)

        def VPNMSUB213SH(self):
            return self.getToken(nasm_x86_64_Parser.VPNMSUB213SH, 0)

        def VPNMSUB231SH(self):
            return self.getToken(nasm_x86_64_Parser.VPNMSUB231SH, 0)

        def VPOPCNTB(self):
            return self.getToken(nasm_x86_64_Parser.VPOPCNTB, 0)

        def VPOPCNTD(self):
            return self.getToken(nasm_x86_64_Parser.VPOPCNTD, 0)

        def VPOPCNTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPOPCNTQ, 0)

        def VPOPCNTW(self):
            return self.getToken(nasm_x86_64_Parser.VPOPCNTW, 0)

        def VPOR(self):
            return self.getToken(nasm_x86_64_Parser.VPOR, 0)

        def VPORD(self):
            return self.getToken(nasm_x86_64_Parser.VPORD, 0)

        def VPORQ(self):
            return self.getToken(nasm_x86_64_Parser.VPORQ, 0)

        def VPPERM(self):
            return self.getToken(nasm_x86_64_Parser.VPPERM, 0)

        def VPROLD(self):
            return self.getToken(nasm_x86_64_Parser.VPROLD, 0)

        def VPROLQ(self):
            return self.getToken(nasm_x86_64_Parser.VPROLQ, 0)

        def VPROLVD(self):
            return self.getToken(nasm_x86_64_Parser.VPROLVD, 0)

        def VPROLVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPROLVQ, 0)

        def VPRORD(self):
            return self.getToken(nasm_x86_64_Parser.VPRORD, 0)

        def VPRORQ(self):
            return self.getToken(nasm_x86_64_Parser.VPRORQ, 0)

        def VPRORVD(self):
            return self.getToken(nasm_x86_64_Parser.VPRORVD, 0)

        def VPRORVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPRORVQ, 0)

        def VPROTB(self):
            return self.getToken(nasm_x86_64_Parser.VPROTB, 0)

        def VPROTD(self):
            return self.getToken(nasm_x86_64_Parser.VPROTD, 0)

        def VPROTQ(self):
            return self.getToken(nasm_x86_64_Parser.VPROTQ, 0)

        def VPROTW(self):
            return self.getToken(nasm_x86_64_Parser.VPROTW, 0)

        def VPSADBW(self):
            return self.getToken(nasm_x86_64_Parser.VPSADBW, 0)

        def VPSCATTERDD(self):
            return self.getToken(nasm_x86_64_Parser.VPSCATTERDD, 0)

        def VPSCATTERDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSCATTERDQ, 0)

        def VPSCATTERQD(self):
            return self.getToken(nasm_x86_64_Parser.VPSCATTERQD, 0)

        def VPSCATTERQQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSCATTERQQ, 0)

        def VPSHAB(self):
            return self.getToken(nasm_x86_64_Parser.VPSHAB, 0)

        def VPSHAD(self):
            return self.getToken(nasm_x86_64_Parser.VPSHAD, 0)

        def VPSHAQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSHAQ, 0)

        def VPSHAW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHAW, 0)

        def VPSHLB(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLB, 0)

        def VPSHLD(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLD, 0)

        def VPSHLDD(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLDD, 0)

        def VPSHLDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLDQ, 0)

        def VPSHLDVD(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLDVD, 0)

        def VPSHLDVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLDVQ, 0)

        def VPSHLDVW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLDVW, 0)

        def VPSHLDW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLDW, 0)

        def VPSHLQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLQ, 0)

        def VPSHLW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHLW, 0)

        def VPSHRDD(self):
            return self.getToken(nasm_x86_64_Parser.VPSHRDD, 0)

        def VPSHRDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSHRDQ, 0)

        def VPSHRDVD(self):
            return self.getToken(nasm_x86_64_Parser.VPSHRDVD, 0)

        def VPSHRDVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSHRDVQ, 0)

        def VPSHRDVW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHRDVW, 0)

        def VPSHRDW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHRDW, 0)

        def VPSHUFB(self):
            return self.getToken(nasm_x86_64_Parser.VPSHUFB, 0)

        def VPSHUFBITQMB(self):
            return self.getToken(nasm_x86_64_Parser.VPSHUFBITQMB, 0)

        def VPSHUFD(self):
            return self.getToken(nasm_x86_64_Parser.VPSHUFD, 0)

        def VPSHUFHW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHUFHW, 0)

        def VPSHUFLW(self):
            return self.getToken(nasm_x86_64_Parser.VPSHUFLW, 0)

        def VPSIGNB(self):
            return self.getToken(nasm_x86_64_Parser.VPSIGNB, 0)

        def VPSIGND(self):
            return self.getToken(nasm_x86_64_Parser.VPSIGND, 0)

        def VPSIGNW(self):
            return self.getToken(nasm_x86_64_Parser.VPSIGNW, 0)

        def VPSLLD(self):
            return self.getToken(nasm_x86_64_Parser.VPSLLD, 0)

        def VPSLLDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSLLDQ, 0)

        def VPSLLQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSLLQ, 0)

        def VPSLLVD(self):
            return self.getToken(nasm_x86_64_Parser.VPSLLVD, 0)

        def VPSLLVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSLLVQ, 0)

        def VPSLLVW(self):
            return self.getToken(nasm_x86_64_Parser.VPSLLVW, 0)

        def VPSLLW(self):
            return self.getToken(nasm_x86_64_Parser.VPSLLW, 0)

        def VPSRAD(self):
            return self.getToken(nasm_x86_64_Parser.VPSRAD, 0)

        def VPSRAQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSRAQ, 0)

        def VPSRAVD(self):
            return self.getToken(nasm_x86_64_Parser.VPSRAVD, 0)

        def VPSRAVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSRAVQ, 0)

        def VPSRAVW(self):
            return self.getToken(nasm_x86_64_Parser.VPSRAVW, 0)

        def VPSRAW(self):
            return self.getToken(nasm_x86_64_Parser.VPSRAW, 0)

        def VPSRLD(self):
            return self.getToken(nasm_x86_64_Parser.VPSRLD, 0)

        def VPSRLDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSRLDQ, 0)

        def VPSRLQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSRLQ, 0)

        def VPSRLVD(self):
            return self.getToken(nasm_x86_64_Parser.VPSRLVD, 0)

        def VPSRLVQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSRLVQ, 0)

        def VPSRLVW(self):
            return self.getToken(nasm_x86_64_Parser.VPSRLVW, 0)

        def VPSRLW(self):
            return self.getToken(nasm_x86_64_Parser.VPSRLW, 0)

        def VPSUBB(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBB, 0)

        def VPSUBD(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBD, 0)

        def VPSUBQ(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBQ, 0)

        def VPSUBSB(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBSB, 0)

        def VPSUBSW(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBSW, 0)

        def VPSUBUSB(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBUSB, 0)

        def VPSUBUSW(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBUSW, 0)

        def VPSUBW(self):
            return self.getToken(nasm_x86_64_Parser.VPSUBW, 0)

        def VPTERNLOGD(self):
            return self.getToken(nasm_x86_64_Parser.VPTERNLOGD, 0)

        def VPTERNLOGQ(self):
            return self.getToken(nasm_x86_64_Parser.VPTERNLOGQ, 0)

        def VPTEST(self):
            return self.getToken(nasm_x86_64_Parser.VPTEST, 0)

        def VPTESTMB(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTMB, 0)

        def VPTESTMD(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTMD, 0)

        def VPTESTMQ(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTMQ, 0)

        def VPTESTMW(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTMW, 0)

        def VPTESTNMB(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTNMB, 0)

        def VPTESTNMD(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTNMD, 0)

        def VPTESTNMQ(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTNMQ, 0)

        def VPTESTNMW(self):
            return self.getToken(nasm_x86_64_Parser.VPTESTNMW, 0)

        def VPUNPCKHBW(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKHBW, 0)

        def VPUNPCKHDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKHDQ, 0)

        def VPUNPCKHQDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKHQDQ, 0)

        def VPUNPCKHWD(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKHWD, 0)

        def VPUNPCKLBW(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKLBW, 0)

        def VPUNPCKLDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKLDQ, 0)

        def VPUNPCKLQDQ(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKLQDQ, 0)

        def VPUNPCKLWD(self):
            return self.getToken(nasm_x86_64_Parser.VPUNPCKLWD, 0)

        def VPXOR(self):
            return self.getToken(nasm_x86_64_Parser.VPXOR, 0)

        def VPXORD(self):
            return self.getToken(nasm_x86_64_Parser.VPXORD, 0)

        def VPXORQ(self):
            return self.getToken(nasm_x86_64_Parser.VPXORQ, 0)

        def VRANGEPD(self):
            return self.getToken(nasm_x86_64_Parser.VRANGEPD, 0)

        def VRANGEPS(self):
            return self.getToken(nasm_x86_64_Parser.VRANGEPS, 0)

        def VRANGESD(self):
            return self.getToken(nasm_x86_64_Parser.VRANGESD, 0)

        def VRANGESS(self):
            return self.getToken(nasm_x86_64_Parser.VRANGESS, 0)

        def VRCP14PD(self):
            return self.getToken(nasm_x86_64_Parser.VRCP14PD, 0)

        def VRCP14PS(self):
            return self.getToken(nasm_x86_64_Parser.VRCP14PS, 0)

        def VRCP14SD(self):
            return self.getToken(nasm_x86_64_Parser.VRCP14SD, 0)

        def VRCP14SS(self):
            return self.getToken(nasm_x86_64_Parser.VRCP14SS, 0)

        def VRCP28PD(self):
            return self.getToken(nasm_x86_64_Parser.VRCP28PD, 0)

        def VRCP28PS(self):
            return self.getToken(nasm_x86_64_Parser.VRCP28PS, 0)

        def VRCP28SD(self):
            return self.getToken(nasm_x86_64_Parser.VRCP28SD, 0)

        def VRCP28SS(self):
            return self.getToken(nasm_x86_64_Parser.VRCP28SS, 0)

        def VRCPPH(self):
            return self.getToken(nasm_x86_64_Parser.VRCPPH, 0)

        def VRCPPS(self):
            return self.getToken(nasm_x86_64_Parser.VRCPPS, 0)

        def VRCPSH(self):
            return self.getToken(nasm_x86_64_Parser.VRCPSH, 0)

        def VRCPSS(self):
            return self.getToken(nasm_x86_64_Parser.VRCPSS, 0)

        def VREDUCEPD(self):
            return self.getToken(nasm_x86_64_Parser.VREDUCEPD, 0)

        def VREDUCEPH(self):
            return self.getToken(nasm_x86_64_Parser.VREDUCEPH, 0)

        def VREDUCEPS(self):
            return self.getToken(nasm_x86_64_Parser.VREDUCEPS, 0)

        def VREDUCESD(self):
            return self.getToken(nasm_x86_64_Parser.VREDUCESD, 0)

        def VREDUCESH(self):
            return self.getToken(nasm_x86_64_Parser.VREDUCESH, 0)

        def VREDUCESS(self):
            return self.getToken(nasm_x86_64_Parser.VREDUCESS, 0)

        def VRNDSCALEPD(self):
            return self.getToken(nasm_x86_64_Parser.VRNDSCALEPD, 0)

        def VRNDSCALEPS(self):
            return self.getToken(nasm_x86_64_Parser.VRNDSCALEPS, 0)

        def VRNDSCALESD(self):
            return self.getToken(nasm_x86_64_Parser.VRNDSCALESD, 0)

        def VRNDSCALESS(self):
            return self.getToken(nasm_x86_64_Parser.VRNDSCALESS, 0)

        def VROUNDPD(self):
            return self.getToken(nasm_x86_64_Parser.VROUNDPD, 0)

        def VROUNDPS(self):
            return self.getToken(nasm_x86_64_Parser.VROUNDPS, 0)

        def VROUNDSD(self):
            return self.getToken(nasm_x86_64_Parser.VROUNDSD, 0)

        def VROUNDSS(self):
            return self.getToken(nasm_x86_64_Parser.VROUNDSS, 0)

        def VRSQRT14PD(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT14PD, 0)

        def VRSQRT14PS(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT14PS, 0)

        def VRSQRT14SD(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT14SD, 0)

        def VRSQRT14SS(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT14SS, 0)

        def VRSQRT28PD(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT28PD, 0)

        def VRSQRT28PS(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT28PS, 0)

        def VRSQRT28SD(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT28SD, 0)

        def VRSQRT28SS(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRT28SS, 0)

        def VRSQRTPH(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRTPH, 0)

        def VRSQRTPS(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRTPS, 0)

        def VRSQRTSH(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRTSH, 0)

        def VRSQRTSS(self):
            return self.getToken(nasm_x86_64_Parser.VRSQRTSS, 0)

        def VSCALEFPD(self):
            return self.getToken(nasm_x86_64_Parser.VSCALEFPD, 0)

        def VSCALEFPH(self):
            return self.getToken(nasm_x86_64_Parser.VSCALEFPH, 0)

        def VSCALEFPS(self):
            return self.getToken(nasm_x86_64_Parser.VSCALEFPS, 0)

        def VSCALEFSD(self):
            return self.getToken(nasm_x86_64_Parser.VSCALEFSD, 0)

        def VSCALEFSH(self):
            return self.getToken(nasm_x86_64_Parser.VSCALEFSH, 0)

        def VSCALEFSS(self):
            return self.getToken(nasm_x86_64_Parser.VSCALEFSS, 0)

        def VSCATTERDPD(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERDPD, 0)

        def VSCATTERDPS(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERDPS, 0)

        def VSCATTERPF0DPD(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF0DPD, 0)

        def VSCATTERPF0DPS(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF0DPS, 0)

        def VSCATTERPF0QPD(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF0QPD, 0)

        def VSCATTERPF0QPS(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF0QPS, 0)

        def VSCATTERPF1DPD(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF1DPD, 0)

        def VSCATTERPF1DPS(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF1DPS, 0)

        def VSCATTERPF1QPD(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF1QPD, 0)

        def VSCATTERPF1QPS(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERPF1QPS, 0)

        def VSCATTERQPD(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERQPD, 0)

        def VSCATTERQPS(self):
            return self.getToken(nasm_x86_64_Parser.VSCATTERQPS, 0)

        def VSHUFF32X4(self):
            return self.getToken(nasm_x86_64_Parser.VSHUFF32X4, 0)

        def VSHUFF64X2(self):
            return self.getToken(nasm_x86_64_Parser.VSHUFF64X2, 0)

        def VSHUFI32X4(self):
            return self.getToken(nasm_x86_64_Parser.VSHUFI32X4, 0)

        def VSHUFI64X2(self):
            return self.getToken(nasm_x86_64_Parser.VSHUFI64X2, 0)

        def VSHUFPD(self):
            return self.getToken(nasm_x86_64_Parser.VSHUFPD, 0)

        def VSHUFPS(self):
            return self.getToken(nasm_x86_64_Parser.VSHUFPS, 0)

        def VSQRTPD(self):
            return self.getToken(nasm_x86_64_Parser.VSQRTPD, 0)

        def VSQRTPH(self):
            return self.getToken(nasm_x86_64_Parser.VSQRTPH, 0)

        def VSQRTPS(self):
            return self.getToken(nasm_x86_64_Parser.VSQRTPS, 0)

        def VSQRTSD(self):
            return self.getToken(nasm_x86_64_Parser.VSQRTSD, 0)

        def VSQRTSH(self):
            return self.getToken(nasm_x86_64_Parser.VSQRTSH, 0)

        def VSQRTSS(self):
            return self.getToken(nasm_x86_64_Parser.VSQRTSS, 0)

        def VSTMXCSR(self):
            return self.getToken(nasm_x86_64_Parser.VSTMXCSR, 0)

        def VSUBPD(self):
            return self.getToken(nasm_x86_64_Parser.VSUBPD, 0)

        def VSUBPH(self):
            return self.getToken(nasm_x86_64_Parser.VSUBPH, 0)

        def VSUBPS(self):
            return self.getToken(nasm_x86_64_Parser.VSUBPS, 0)

        def VSUBSD(self):
            return self.getToken(nasm_x86_64_Parser.VSUBSD, 0)

        def VSUBSH(self):
            return self.getToken(nasm_x86_64_Parser.VSUBSH, 0)

        def VSUBSS(self):
            return self.getToken(nasm_x86_64_Parser.VSUBSS, 0)

        def VTESTPD(self):
            return self.getToken(nasm_x86_64_Parser.VTESTPD, 0)

        def VTESTPS(self):
            return self.getToken(nasm_x86_64_Parser.VTESTPS, 0)

        def VUCOMISD(self):
            return self.getToken(nasm_x86_64_Parser.VUCOMISD, 0)

        def VUCOMISH(self):
            return self.getToken(nasm_x86_64_Parser.VUCOMISH, 0)

        def VUCOMISS(self):
            return self.getToken(nasm_x86_64_Parser.VUCOMISS, 0)

        def VUNPCKHPD(self):
            return self.getToken(nasm_x86_64_Parser.VUNPCKHPD, 0)

        def VUNPCKHPS(self):
            return self.getToken(nasm_x86_64_Parser.VUNPCKHPS, 0)

        def VUNPCKLPD(self):
            return self.getToken(nasm_x86_64_Parser.VUNPCKLPD, 0)

        def VUNPCKLPS(self):
            return self.getToken(nasm_x86_64_Parser.VUNPCKLPS, 0)

        def VXORPD(self):
            return self.getToken(nasm_x86_64_Parser.VXORPD, 0)

        def VXORPS(self):
            return self.getToken(nasm_x86_64_Parser.VXORPS, 0)

        def VZEROALL(self):
            return self.getToken(nasm_x86_64_Parser.VZEROALL, 0)

        def VZEROUPPER(self):
            return self.getToken(nasm_x86_64_Parser.VZEROUPPER, 0)

        def WBNOINVD(self):
            return self.getToken(nasm_x86_64_Parser.WBNOINVD, 0)

        def WRFSBASE(self):
            return self.getToken(nasm_x86_64_Parser.WRFSBASE, 0)

        def WRGSBASE(self):
            return self.getToken(nasm_x86_64_Parser.WRGSBASE, 0)

        def WRMSRLIST(self):
            return self.getToken(nasm_x86_64_Parser.WRMSRLIST, 0)

        def WRMSRNS(self):
            return self.getToken(nasm_x86_64_Parser.WRMSRNS, 0)

        def WRPKRU(self):
            return self.getToken(nasm_x86_64_Parser.WRPKRU, 0)

        def WRSSD(self):
            return self.getToken(nasm_x86_64_Parser.WRSSD, 0)

        def WRSSQ(self):
            return self.getToken(nasm_x86_64_Parser.WRSSQ, 0)

        def WRUSSD(self):
            return self.getToken(nasm_x86_64_Parser.WRUSSD, 0)

        def WRUSSQ(self):
            return self.getToken(nasm_x86_64_Parser.WRUSSQ, 0)

        def XABORT(self):
            return self.getToken(nasm_x86_64_Parser.XABORT, 0)

        def XBEGIN(self):
            return self.getToken(nasm_x86_64_Parser.XBEGIN, 0)

        def XCRYPTCBC(self):
            return self.getToken(nasm_x86_64_Parser.XCRYPTCBC, 0)

        def XCRYPTCFB(self):
            return self.getToken(nasm_x86_64_Parser.XCRYPTCFB, 0)

        def XCRYPTCTR(self):
            return self.getToken(nasm_x86_64_Parser.XCRYPTCTR, 0)

        def XCRYPTECB(self):
            return self.getToken(nasm_x86_64_Parser.XCRYPTECB, 0)

        def XCRYPTOFB(self):
            return self.getToken(nasm_x86_64_Parser.XCRYPTOFB, 0)

        def XEND(self):
            return self.getToken(nasm_x86_64_Parser.XEND, 0)

        def XGETBV(self):
            return self.getToken(nasm_x86_64_Parser.XGETBV, 0)

        def XORPD(self):
            return self.getToken(nasm_x86_64_Parser.XORPD, 0)

        def XORPS(self):
            return self.getToken(nasm_x86_64_Parser.XORPS, 0)

        def XRESLDTRK(self):
            return self.getToken(nasm_x86_64_Parser.XRESLDTRK, 0)

        def XRSTOR(self):
            return self.getToken(nasm_x86_64_Parser.XRSTOR, 0)

        def XRSTOR64(self):
            return self.getToken(nasm_x86_64_Parser.XRSTOR64, 0)

        def XRSTORS(self):
            return self.getToken(nasm_x86_64_Parser.XRSTORS, 0)

        def XRSTORS64(self):
            return self.getToken(nasm_x86_64_Parser.XRSTORS64, 0)

        def XSAVE(self):
            return self.getToken(nasm_x86_64_Parser.XSAVE, 0)

        def XSAVE64(self):
            return self.getToken(nasm_x86_64_Parser.XSAVE64, 0)

        def XSAVEC(self):
            return self.getToken(nasm_x86_64_Parser.XSAVEC, 0)

        def XSAVEC64(self):
            return self.getToken(nasm_x86_64_Parser.XSAVEC64, 0)

        def XSAVEOPT(self):
            return self.getToken(nasm_x86_64_Parser.XSAVEOPT, 0)

        def XSAVEOPT64(self):
            return self.getToken(nasm_x86_64_Parser.XSAVEOPT64, 0)

        def XSAVES(self):
            return self.getToken(nasm_x86_64_Parser.XSAVES, 0)

        def XSAVES64(self):
            return self.getToken(nasm_x86_64_Parser.XSAVES64, 0)

        def XSETBV(self):
            return self.getToken(nasm_x86_64_Parser.XSETBV, 0)

        def XSHA1(self):
            return self.getToken(nasm_x86_64_Parser.XSHA1, 0)

        def XSHA256(self):
            return self.getToken(nasm_x86_64_Parser.XSHA256, 0)

        def XSTORE(self):
            return self.getToken(nasm_x86_64_Parser.XSTORE, 0)

        def XSUSLDTRK(self):
            return self.getToken(nasm_x86_64_Parser.XSUSLDTRK, 0)

        def XTEST(self):
            return self.getToken(nasm_x86_64_Parser.XTEST, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_opcode

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOpcode" ):
                listener.enterOpcode(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOpcode" ):
                listener.exitOpcode(self)




    def opcode(self):

        localctx = nasm_x86_64_Parser.OpcodeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_opcode)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 810
            _la = self._input.LA(1)
            if not(((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -1) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & -1) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & -1) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & -1) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & 281474976710655) != 0) or ((((_la - 811)) & ~0x3f) == 0 and ((1 << (_la - 811)) & -1) != 0) or ((((_la - 875)) & ~0x3f) == 0 and ((1 << (_la - 875)) & -1) != 0) or ((((_la - 939)) & ~0x3f) == 0 and ((1 << (_la - 939)) & -1) != 0) or ((((_la - 1003)) & ~0x3f) == 0 and ((1 << (_la - 1003)) & -1) != 0) or ((((_la - 1067)) & ~0x3f) == 0 and ((1 << (_la - 1067)) & -1) != 0) or ((((_la - 1131)) & ~0x3f) == 0 and ((1 << (_la - 1131)) & -1) != 0) or ((((_la - 1195)) & ~0x3f) == 0 and ((1 << (_la - 1195)) & -1) != 0) or ((((_la - 1259)) & ~0x3f) == 0 and ((1 << (_la - 1259)) & -1) != 0) or ((((_la - 1323)) & ~0x3f) == 0 and ((1 << (_la - 1323)) & -1) != 0) or ((((_la - 1387)) & ~0x3f) == 0 and ((1 << (_la - 1387)) & -1) != 0) or ((((_la - 1451)) & ~0x3f) == 0 and ((1 << (_la - 1451)) & -1) != 0) or ((((_la - 1515)) & ~0x3f) == 0 and ((1 << (_la - 1515)) & -1) != 0) or ((((_la - 1579)) & ~0x3f) == 0 and ((1 << (_la - 1579)) & -1) != 0) or ((((_la - 1643)) & ~0x3f) == 0 and ((1 << (_la - 1643)) & -1) != 0) or ((((_la - 1707)) & ~0x3f) == 0 and ((1 << (_la - 1707)) & -1) != 0) or ((((_la - 1771)) & ~0x3f) == 0 and ((1 << (_la - 1771)) & -1) != 0) or ((((_la - 1835)) & ~0x3f) == 0 and ((1 << (_la - 1835)) & -1) != 0) or ((((_la - 1899)) & ~0x3f) == 0 and ((1 << (_la - 1899)) & -1) != 0) or ((((_la - 1963)) & ~0x3f) == 0 and ((1 << (_la - 1963)) & -1) != 0) or ((((_la - 2027)) & ~0x3f) == 0 and ((1 << (_la - 2027)) & -1) != 0) or ((((_la - 2091)) & ~0x3f) == 0 and ((1 << (_la - 2091)) & -1) != 0) or ((((_la - 2155)) & ~0x3f) == 0 and ((1 << (_la - 2155)) & -1) != 0) or ((((_la - 2219)) & ~0x3f) == 0 and ((1 << (_la - 2219)) & -1) != 0) or ((((_la - 2283)) & ~0x3f) == 0 and ((1 << (_la - 2283)) & -1) != 0) or ((((_la - 2347)) & ~0x3f) == 0 and ((1 << (_la - 2347)) & -1) != 0) or ((((_la - 2411)) & ~0x3f) == 0 and ((1 << (_la - 2411)) & -1) != 0) or ((((_la - 2475)) & ~0x3f) == 0 and ((1 << (_la - 2475)) & 140737488355327) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperandContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def register(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.RegisterContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.RegisterContext,i)


        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def LEFT_BRACKET(self):
            return self.getToken(nasm_x86_64_Parser.LEFT_BRACKET, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.ExpressionContext,i)


        def RIGHT_BRACKET(self):
            return self.getToken(nasm_x86_64_Parser.RIGHT_BRACKET, 0)

        def size(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.SizeContext,0)


        def COLON(self):
            return self.getToken(nasm_x86_64_Parser.COLON, 0)

        def string(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.StringContext,0)


        def float_number(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Float_numberContext,0)


        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COMMA)
            else:
                return self.getToken(nasm_x86_64_Parser.COMMA, i)

        def strict(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.StrictContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_operand

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOperand" ):
                listener.enterOperand(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOperand" ):
                listener.exitOperand(self)




    def operand(self):

        localctx = nasm_x86_64_Parser.OperandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_operand)
        self._la = 0 # Token type
        try:
            self.state = 851
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 813
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 66846720) != 0):
                    self.state = 812
                    self.size()


                self.state = 818
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
                if la_ == 1:
                    self.state = 815
                    self.register()
                    self.state = 816
                    self.match(nasm_x86_64_Parser.COLON)


                self.state = 826
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810]:
                    self.state = 820
                    self.register()
                    pass
                elif token in [2622]:
                    self.state = 821
                    self.name()
                    pass
                elif token in [31]:
                    self.state = 822
                    self.match(nasm_x86_64_Parser.LEFT_BRACKET)
                    self.state = 823
                    self.expression()
                    self.state = 824
                    self.match(nasm_x86_64_Parser.RIGHT_BRACKET)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 832
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 66846720) != 0) or _la==2610:
                    self.state = 829
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==2610:
                        self.state = 828
                        self.strict()


                    self.state = 831
                    self.size()


                self.state = 848
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [2618]:
                    self.state = 834
                    self.string()
                    pass
                elif token in [2612]:
                    self.state = 835
                    self.float_number()
                    pass
                elif token in [2613, 2615, 2616, 2617]:
                    self.state = 836
                    self.integer()
                    pass
                elif token in [31]:
                    self.state = 837
                    self.match(nasm_x86_64_Parser.LEFT_BRACKET)
                    self.state = 838
                    self.expression()
                    self.state = 843
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==27:
                        self.state = 839
                        self.match(nasm_x86_64_Parser.COMMA)
                        self.state = 840
                        self.expression()
                        self.state = 845
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 846
                    self.match(nasm_x86_64_Parser.RIGHT_BRACKET)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 850
                self.expression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RegisterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AL(self):
            return self.getToken(nasm_x86_64_Parser.AL, 0)

        def AH(self):
            return self.getToken(nasm_x86_64_Parser.AH, 0)

        def AX(self):
            return self.getToken(nasm_x86_64_Parser.AX, 0)

        def EAX(self):
            return self.getToken(nasm_x86_64_Parser.EAX, 0)

        def RAX(self):
            return self.getToken(nasm_x86_64_Parser.RAX, 0)

        def BL(self):
            return self.getToken(nasm_x86_64_Parser.BL, 0)

        def BH(self):
            return self.getToken(nasm_x86_64_Parser.BH, 0)

        def BX(self):
            return self.getToken(nasm_x86_64_Parser.BX, 0)

        def EBX(self):
            return self.getToken(nasm_x86_64_Parser.EBX, 0)

        def RBX(self):
            return self.getToken(nasm_x86_64_Parser.RBX, 0)

        def CL(self):
            return self.getToken(nasm_x86_64_Parser.CL, 0)

        def CH(self):
            return self.getToken(nasm_x86_64_Parser.CH, 0)

        def CX(self):
            return self.getToken(nasm_x86_64_Parser.CX, 0)

        def ECX(self):
            return self.getToken(nasm_x86_64_Parser.ECX, 0)

        def RCX(self):
            return self.getToken(nasm_x86_64_Parser.RCX, 0)

        def DL(self):
            return self.getToken(nasm_x86_64_Parser.DL, 0)

        def DH(self):
            return self.getToken(nasm_x86_64_Parser.DH, 0)

        def DX(self):
            return self.getToken(nasm_x86_64_Parser.DX, 0)

        def EDX(self):
            return self.getToken(nasm_x86_64_Parser.EDX, 0)

        def RDX(self):
            return self.getToken(nasm_x86_64_Parser.RDX, 0)

        def SPL(self):
            return self.getToken(nasm_x86_64_Parser.SPL, 0)

        def SP(self):
            return self.getToken(nasm_x86_64_Parser.SP, 0)

        def ESP(self):
            return self.getToken(nasm_x86_64_Parser.ESP, 0)

        def RSP(self):
            return self.getToken(nasm_x86_64_Parser.RSP, 0)

        def BPL(self):
            return self.getToken(nasm_x86_64_Parser.BPL, 0)

        def BP(self):
            return self.getToken(nasm_x86_64_Parser.BP, 0)

        def EBP(self):
            return self.getToken(nasm_x86_64_Parser.EBP, 0)

        def RBP(self):
            return self.getToken(nasm_x86_64_Parser.RBP, 0)

        def SIL(self):
            return self.getToken(nasm_x86_64_Parser.SIL, 0)

        def SI(self):
            return self.getToken(nasm_x86_64_Parser.SI, 0)

        def ESI(self):
            return self.getToken(nasm_x86_64_Parser.ESI, 0)

        def RSI(self):
            return self.getToken(nasm_x86_64_Parser.RSI, 0)

        def DIL(self):
            return self.getToken(nasm_x86_64_Parser.DIL, 0)

        def DI(self):
            return self.getToken(nasm_x86_64_Parser.DI, 0)

        def EDI(self):
            return self.getToken(nasm_x86_64_Parser.EDI, 0)

        def RDI(self):
            return self.getToken(nasm_x86_64_Parser.RDI, 0)

        def R8B(self):
            return self.getToken(nasm_x86_64_Parser.R8B, 0)

        def R9B(self):
            return self.getToken(nasm_x86_64_Parser.R9B, 0)

        def R10B(self):
            return self.getToken(nasm_x86_64_Parser.R10B, 0)

        def R11B(self):
            return self.getToken(nasm_x86_64_Parser.R11B, 0)

        def R12B(self):
            return self.getToken(nasm_x86_64_Parser.R12B, 0)

        def R13B(self):
            return self.getToken(nasm_x86_64_Parser.R13B, 0)

        def R14B(self):
            return self.getToken(nasm_x86_64_Parser.R14B, 0)

        def R15B(self):
            return self.getToken(nasm_x86_64_Parser.R15B, 0)

        def R8W(self):
            return self.getToken(nasm_x86_64_Parser.R8W, 0)

        def R9W(self):
            return self.getToken(nasm_x86_64_Parser.R9W, 0)

        def R10W(self):
            return self.getToken(nasm_x86_64_Parser.R10W, 0)

        def R11W(self):
            return self.getToken(nasm_x86_64_Parser.R11W, 0)

        def R12W(self):
            return self.getToken(nasm_x86_64_Parser.R12W, 0)

        def R13W(self):
            return self.getToken(nasm_x86_64_Parser.R13W, 0)

        def R14W(self):
            return self.getToken(nasm_x86_64_Parser.R14W, 0)

        def R15W(self):
            return self.getToken(nasm_x86_64_Parser.R15W, 0)

        def R8D(self):
            return self.getToken(nasm_x86_64_Parser.R8D, 0)

        def R9D(self):
            return self.getToken(nasm_x86_64_Parser.R9D, 0)

        def R10D(self):
            return self.getToken(nasm_x86_64_Parser.R10D, 0)

        def R11D(self):
            return self.getToken(nasm_x86_64_Parser.R11D, 0)

        def R12D(self):
            return self.getToken(nasm_x86_64_Parser.R12D, 0)

        def R13D(self):
            return self.getToken(nasm_x86_64_Parser.R13D, 0)

        def R14D(self):
            return self.getToken(nasm_x86_64_Parser.R14D, 0)

        def R15D(self):
            return self.getToken(nasm_x86_64_Parser.R15D, 0)

        def R8(self):
            return self.getToken(nasm_x86_64_Parser.R8, 0)

        def R9(self):
            return self.getToken(nasm_x86_64_Parser.R9, 0)

        def R10(self):
            return self.getToken(nasm_x86_64_Parser.R10, 0)

        def R11(self):
            return self.getToken(nasm_x86_64_Parser.R11, 0)

        def R12(self):
            return self.getToken(nasm_x86_64_Parser.R12, 0)

        def R13(self):
            return self.getToken(nasm_x86_64_Parser.R13, 0)

        def R14(self):
            return self.getToken(nasm_x86_64_Parser.R14, 0)

        def R15(self):
            return self.getToken(nasm_x86_64_Parser.R15, 0)

        def IP(self):
            return self.getToken(nasm_x86_64_Parser.IP, 0)

        def EIP(self):
            return self.getToken(nasm_x86_64_Parser.EIP, 0)

        def RIP(self):
            return self.getToken(nasm_x86_64_Parser.RIP, 0)

        def ES(self):
            return self.getToken(nasm_x86_64_Parser.ES, 0)

        def CS(self):
            return self.getToken(nasm_x86_64_Parser.CS, 0)

        def SS(self):
            return self.getToken(nasm_x86_64_Parser.SS, 0)

        def DS(self):
            return self.getToken(nasm_x86_64_Parser.DS, 0)

        def FS(self):
            return self.getToken(nasm_x86_64_Parser.FS, 0)

        def GS(self):
            return self.getToken(nasm_x86_64_Parser.GS, 0)

        def SEGR6(self):
            return self.getToken(nasm_x86_64_Parser.SEGR6, 0)

        def SEGR7(self):
            return self.getToken(nasm_x86_64_Parser.SEGR7, 0)

        def CR0(self):
            return self.getToken(nasm_x86_64_Parser.CR0, 0)

        def CR1(self):
            return self.getToken(nasm_x86_64_Parser.CR1, 0)

        def CR2(self):
            return self.getToken(nasm_x86_64_Parser.CR2, 0)

        def CR3(self):
            return self.getToken(nasm_x86_64_Parser.CR3, 0)

        def CR4(self):
            return self.getToken(nasm_x86_64_Parser.CR4, 0)

        def CR5(self):
            return self.getToken(nasm_x86_64_Parser.CR5, 0)

        def CR6(self):
            return self.getToken(nasm_x86_64_Parser.CR6, 0)

        def CR7(self):
            return self.getToken(nasm_x86_64_Parser.CR7, 0)

        def CR8(self):
            return self.getToken(nasm_x86_64_Parser.CR8, 0)

        def CR9(self):
            return self.getToken(nasm_x86_64_Parser.CR9, 0)

        def CR10(self):
            return self.getToken(nasm_x86_64_Parser.CR10, 0)

        def CR11(self):
            return self.getToken(nasm_x86_64_Parser.CR11, 0)

        def CR12(self):
            return self.getToken(nasm_x86_64_Parser.CR12, 0)

        def CR13(self):
            return self.getToken(nasm_x86_64_Parser.CR13, 0)

        def CR14(self):
            return self.getToken(nasm_x86_64_Parser.CR14, 0)

        def CR15(self):
            return self.getToken(nasm_x86_64_Parser.CR15, 0)

        def DR0(self):
            return self.getToken(nasm_x86_64_Parser.DR0, 0)

        def DR1(self):
            return self.getToken(nasm_x86_64_Parser.DR1, 0)

        def DR2(self):
            return self.getToken(nasm_x86_64_Parser.DR2, 0)

        def DR3(self):
            return self.getToken(nasm_x86_64_Parser.DR3, 0)

        def DR4(self):
            return self.getToken(nasm_x86_64_Parser.DR4, 0)

        def DR5(self):
            return self.getToken(nasm_x86_64_Parser.DR5, 0)

        def DR6(self):
            return self.getToken(nasm_x86_64_Parser.DR6, 0)

        def DR7(self):
            return self.getToken(nasm_x86_64_Parser.DR7, 0)

        def DR8(self):
            return self.getToken(nasm_x86_64_Parser.DR8, 0)

        def DR9(self):
            return self.getToken(nasm_x86_64_Parser.DR9, 0)

        def DR10(self):
            return self.getToken(nasm_x86_64_Parser.DR10, 0)

        def DR11(self):
            return self.getToken(nasm_x86_64_Parser.DR11, 0)

        def DR12(self):
            return self.getToken(nasm_x86_64_Parser.DR12, 0)

        def DR13(self):
            return self.getToken(nasm_x86_64_Parser.DR13, 0)

        def DR14(self):
            return self.getToken(nasm_x86_64_Parser.DR14, 0)

        def DR15(self):
            return self.getToken(nasm_x86_64_Parser.DR15, 0)

        def TR0(self):
            return self.getToken(nasm_x86_64_Parser.TR0, 0)

        def TR1(self):
            return self.getToken(nasm_x86_64_Parser.TR1, 0)

        def TR2(self):
            return self.getToken(nasm_x86_64_Parser.TR2, 0)

        def TR3(self):
            return self.getToken(nasm_x86_64_Parser.TR3, 0)

        def TR4(self):
            return self.getToken(nasm_x86_64_Parser.TR4, 0)

        def TR5(self):
            return self.getToken(nasm_x86_64_Parser.TR5, 0)

        def TR6(self):
            return self.getToken(nasm_x86_64_Parser.TR6, 0)

        def TR7(self):
            return self.getToken(nasm_x86_64_Parser.TR7, 0)

        def ST0(self):
            return self.getToken(nasm_x86_64_Parser.ST0, 0)

        def ST1(self):
            return self.getToken(nasm_x86_64_Parser.ST1, 0)

        def ST2(self):
            return self.getToken(nasm_x86_64_Parser.ST2, 0)

        def ST3(self):
            return self.getToken(nasm_x86_64_Parser.ST3, 0)

        def ST4(self):
            return self.getToken(nasm_x86_64_Parser.ST4, 0)

        def ST5(self):
            return self.getToken(nasm_x86_64_Parser.ST5, 0)

        def ST6(self):
            return self.getToken(nasm_x86_64_Parser.ST6, 0)

        def ST7(self):
            return self.getToken(nasm_x86_64_Parser.ST7, 0)

        def MM0(self):
            return self.getToken(nasm_x86_64_Parser.MM0, 0)

        def MM1(self):
            return self.getToken(nasm_x86_64_Parser.MM1, 0)

        def MM2(self):
            return self.getToken(nasm_x86_64_Parser.MM2, 0)

        def MM3(self):
            return self.getToken(nasm_x86_64_Parser.MM3, 0)

        def MM4(self):
            return self.getToken(nasm_x86_64_Parser.MM4, 0)

        def MM5(self):
            return self.getToken(nasm_x86_64_Parser.MM5, 0)

        def MM6(self):
            return self.getToken(nasm_x86_64_Parser.MM6, 0)

        def MM7(self):
            return self.getToken(nasm_x86_64_Parser.MM7, 0)

        def XMM0(self):
            return self.getToken(nasm_x86_64_Parser.XMM0, 0)

        def XMM1(self):
            return self.getToken(nasm_x86_64_Parser.XMM1, 0)

        def XMM2(self):
            return self.getToken(nasm_x86_64_Parser.XMM2, 0)

        def XMM3(self):
            return self.getToken(nasm_x86_64_Parser.XMM3, 0)

        def XMM4(self):
            return self.getToken(nasm_x86_64_Parser.XMM4, 0)

        def XMM5(self):
            return self.getToken(nasm_x86_64_Parser.XMM5, 0)

        def XMM6(self):
            return self.getToken(nasm_x86_64_Parser.XMM6, 0)

        def XMM7(self):
            return self.getToken(nasm_x86_64_Parser.XMM7, 0)

        def XMM8(self):
            return self.getToken(nasm_x86_64_Parser.XMM8, 0)

        def XMM9(self):
            return self.getToken(nasm_x86_64_Parser.XMM9, 0)

        def XMM10(self):
            return self.getToken(nasm_x86_64_Parser.XMM10, 0)

        def XMM11(self):
            return self.getToken(nasm_x86_64_Parser.XMM11, 0)

        def XMM12(self):
            return self.getToken(nasm_x86_64_Parser.XMM12, 0)

        def XMM13(self):
            return self.getToken(nasm_x86_64_Parser.XMM13, 0)

        def XMM14(self):
            return self.getToken(nasm_x86_64_Parser.XMM14, 0)

        def XMM15(self):
            return self.getToken(nasm_x86_64_Parser.XMM15, 0)

        def XMM16(self):
            return self.getToken(nasm_x86_64_Parser.XMM16, 0)

        def XMM17(self):
            return self.getToken(nasm_x86_64_Parser.XMM17, 0)

        def XMM18(self):
            return self.getToken(nasm_x86_64_Parser.XMM18, 0)

        def XMM19(self):
            return self.getToken(nasm_x86_64_Parser.XMM19, 0)

        def XMM20(self):
            return self.getToken(nasm_x86_64_Parser.XMM20, 0)

        def XMM21(self):
            return self.getToken(nasm_x86_64_Parser.XMM21, 0)

        def XMM22(self):
            return self.getToken(nasm_x86_64_Parser.XMM22, 0)

        def XMM23(self):
            return self.getToken(nasm_x86_64_Parser.XMM23, 0)

        def XMM24(self):
            return self.getToken(nasm_x86_64_Parser.XMM24, 0)

        def XMM25(self):
            return self.getToken(nasm_x86_64_Parser.XMM25, 0)

        def XMM26(self):
            return self.getToken(nasm_x86_64_Parser.XMM26, 0)

        def XMM27(self):
            return self.getToken(nasm_x86_64_Parser.XMM27, 0)

        def XMM28(self):
            return self.getToken(nasm_x86_64_Parser.XMM28, 0)

        def XMM29(self):
            return self.getToken(nasm_x86_64_Parser.XMM29, 0)

        def XMM30(self):
            return self.getToken(nasm_x86_64_Parser.XMM30, 0)

        def XMM31(self):
            return self.getToken(nasm_x86_64_Parser.XMM31, 0)

        def YMM0(self):
            return self.getToken(nasm_x86_64_Parser.YMM0, 0)

        def YMM1(self):
            return self.getToken(nasm_x86_64_Parser.YMM1, 0)

        def YMM2(self):
            return self.getToken(nasm_x86_64_Parser.YMM2, 0)

        def YMM3(self):
            return self.getToken(nasm_x86_64_Parser.YMM3, 0)

        def YMM4(self):
            return self.getToken(nasm_x86_64_Parser.YMM4, 0)

        def YMM5(self):
            return self.getToken(nasm_x86_64_Parser.YMM5, 0)

        def YMM6(self):
            return self.getToken(nasm_x86_64_Parser.YMM6, 0)

        def YMM7(self):
            return self.getToken(nasm_x86_64_Parser.YMM7, 0)

        def YMM8(self):
            return self.getToken(nasm_x86_64_Parser.YMM8, 0)

        def YMM9(self):
            return self.getToken(nasm_x86_64_Parser.YMM9, 0)

        def YMM10(self):
            return self.getToken(nasm_x86_64_Parser.YMM10, 0)

        def YMM11(self):
            return self.getToken(nasm_x86_64_Parser.YMM11, 0)

        def YMM12(self):
            return self.getToken(nasm_x86_64_Parser.YMM12, 0)

        def YMM13(self):
            return self.getToken(nasm_x86_64_Parser.YMM13, 0)

        def YMM14(self):
            return self.getToken(nasm_x86_64_Parser.YMM14, 0)

        def YMM15(self):
            return self.getToken(nasm_x86_64_Parser.YMM15, 0)

        def YMM16(self):
            return self.getToken(nasm_x86_64_Parser.YMM16, 0)

        def YMM17(self):
            return self.getToken(nasm_x86_64_Parser.YMM17, 0)

        def YMM18(self):
            return self.getToken(nasm_x86_64_Parser.YMM18, 0)

        def YMM19(self):
            return self.getToken(nasm_x86_64_Parser.YMM19, 0)

        def YMM20(self):
            return self.getToken(nasm_x86_64_Parser.YMM20, 0)

        def YMM21(self):
            return self.getToken(nasm_x86_64_Parser.YMM21, 0)

        def YMM22(self):
            return self.getToken(nasm_x86_64_Parser.YMM22, 0)

        def YMM23(self):
            return self.getToken(nasm_x86_64_Parser.YMM23, 0)

        def YMM24(self):
            return self.getToken(nasm_x86_64_Parser.YMM24, 0)

        def YMM25(self):
            return self.getToken(nasm_x86_64_Parser.YMM25, 0)

        def YMM26(self):
            return self.getToken(nasm_x86_64_Parser.YMM26, 0)

        def YMM27(self):
            return self.getToken(nasm_x86_64_Parser.YMM27, 0)

        def YMM28(self):
            return self.getToken(nasm_x86_64_Parser.YMM28, 0)

        def YMM29(self):
            return self.getToken(nasm_x86_64_Parser.YMM29, 0)

        def YMM30(self):
            return self.getToken(nasm_x86_64_Parser.YMM30, 0)

        def YMM31(self):
            return self.getToken(nasm_x86_64_Parser.YMM31, 0)

        def ZMM0(self):
            return self.getToken(nasm_x86_64_Parser.ZMM0, 0)

        def ZMM1(self):
            return self.getToken(nasm_x86_64_Parser.ZMM1, 0)

        def ZMM2(self):
            return self.getToken(nasm_x86_64_Parser.ZMM2, 0)

        def ZMM3(self):
            return self.getToken(nasm_x86_64_Parser.ZMM3, 0)

        def ZMM4(self):
            return self.getToken(nasm_x86_64_Parser.ZMM4, 0)

        def ZMM5(self):
            return self.getToken(nasm_x86_64_Parser.ZMM5, 0)

        def ZMM6(self):
            return self.getToken(nasm_x86_64_Parser.ZMM6, 0)

        def ZMM7(self):
            return self.getToken(nasm_x86_64_Parser.ZMM7, 0)

        def ZMM8(self):
            return self.getToken(nasm_x86_64_Parser.ZMM8, 0)

        def ZMM9(self):
            return self.getToken(nasm_x86_64_Parser.ZMM9, 0)

        def ZMM10(self):
            return self.getToken(nasm_x86_64_Parser.ZMM10, 0)

        def ZMM11(self):
            return self.getToken(nasm_x86_64_Parser.ZMM11, 0)

        def ZMM12(self):
            return self.getToken(nasm_x86_64_Parser.ZMM12, 0)

        def ZMM13(self):
            return self.getToken(nasm_x86_64_Parser.ZMM13, 0)

        def ZMM14(self):
            return self.getToken(nasm_x86_64_Parser.ZMM14, 0)

        def ZMM15(self):
            return self.getToken(nasm_x86_64_Parser.ZMM15, 0)

        def ZMM16(self):
            return self.getToken(nasm_x86_64_Parser.ZMM16, 0)

        def ZMM17(self):
            return self.getToken(nasm_x86_64_Parser.ZMM17, 0)

        def ZMM18(self):
            return self.getToken(nasm_x86_64_Parser.ZMM18, 0)

        def ZMM19(self):
            return self.getToken(nasm_x86_64_Parser.ZMM19, 0)

        def ZMM20(self):
            return self.getToken(nasm_x86_64_Parser.ZMM20, 0)

        def ZMM21(self):
            return self.getToken(nasm_x86_64_Parser.ZMM21, 0)

        def ZMM22(self):
            return self.getToken(nasm_x86_64_Parser.ZMM22, 0)

        def ZMM23(self):
            return self.getToken(nasm_x86_64_Parser.ZMM23, 0)

        def ZMM24(self):
            return self.getToken(nasm_x86_64_Parser.ZMM24, 0)

        def ZMM25(self):
            return self.getToken(nasm_x86_64_Parser.ZMM25, 0)

        def ZMM26(self):
            return self.getToken(nasm_x86_64_Parser.ZMM26, 0)

        def ZMM27(self):
            return self.getToken(nasm_x86_64_Parser.ZMM27, 0)

        def ZMM28(self):
            return self.getToken(nasm_x86_64_Parser.ZMM28, 0)

        def ZMM29(self):
            return self.getToken(nasm_x86_64_Parser.ZMM29, 0)

        def ZMM30(self):
            return self.getToken(nasm_x86_64_Parser.ZMM30, 0)

        def ZMM31(self):
            return self.getToken(nasm_x86_64_Parser.ZMM31, 0)

        def TMM0(self):
            return self.getToken(nasm_x86_64_Parser.TMM0, 0)

        def TMM1(self):
            return self.getToken(nasm_x86_64_Parser.TMM1, 0)

        def TMM2(self):
            return self.getToken(nasm_x86_64_Parser.TMM2, 0)

        def TMM3(self):
            return self.getToken(nasm_x86_64_Parser.TMM3, 0)

        def TMM4(self):
            return self.getToken(nasm_x86_64_Parser.TMM4, 0)

        def TMM5(self):
            return self.getToken(nasm_x86_64_Parser.TMM5, 0)

        def TMM6(self):
            return self.getToken(nasm_x86_64_Parser.TMM6, 0)

        def TMM7(self):
            return self.getToken(nasm_x86_64_Parser.TMM7, 0)

        def K0(self):
            return self.getToken(nasm_x86_64_Parser.K0, 0)

        def K1(self):
            return self.getToken(nasm_x86_64_Parser.K1, 0)

        def K2(self):
            return self.getToken(nasm_x86_64_Parser.K2, 0)

        def K3(self):
            return self.getToken(nasm_x86_64_Parser.K3, 0)

        def K4(self):
            return self.getToken(nasm_x86_64_Parser.K4, 0)

        def K5(self):
            return self.getToken(nasm_x86_64_Parser.K5, 0)

        def K6(self):
            return self.getToken(nasm_x86_64_Parser.K6, 0)

        def K7(self):
            return self.getToken(nasm_x86_64_Parser.K7, 0)

        def BND0(self):
            return self.getToken(nasm_x86_64_Parser.BND0, 0)

        def BND1(self):
            return self.getToken(nasm_x86_64_Parser.BND1, 0)

        def BND2(self):
            return self.getToken(nasm_x86_64_Parser.BND2, 0)

        def BND3(self):
            return self.getToken(nasm_x86_64_Parser.BND3, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_register

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRegister" ):
                listener.enterRegister(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRegister" ):
                listener.exitRegister(self)




    def register(self):

        localctx = nasm_x86_64_Parser.RegisterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_register)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 853
            _la = self._input.LA(1)
            if not(((((_la - 560)) & ~0x3f) == 0 and ((1 << (_la - 560)) & -1) != 0) or ((((_la - 624)) & ~0x3f) == 0 and ((1 << (_la - 624)) & -1) != 0) or ((((_la - 688)) & ~0x3f) == 0 and ((1 << (_la - 688)) & -1) != 0) or ((((_la - 752)) & ~0x3f) == 0 and ((1 << (_la - 752)) & 576460752303423487) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StrictContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRICT(self):
            return self.getToken(nasm_x86_64_Parser.STRICT, 0)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_strict

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStrict" ):
                listener.enterStrict(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStrict" ):
                listener.exitStrict(self)




    def strict(self):

        localctx = nasm_x86_64_Parser.StrictContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_strict)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 855
            self.match(nasm_x86_64_Parser.STRICT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Macro_callContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def LEFT_PARENTHESIS(self):
            return self.getToken(nasm_x86_64_Parser.LEFT_PARENTHESIS, 0)

        def RIGHT_PARENTHESIS(self):
            return self.getToken(nasm_x86_64_Parser.RIGHT_PARENTHESIS, 0)

        def macro_param(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(nasm_x86_64_Parser.Macro_paramContext)
            else:
                return self.getTypedRuleContext(nasm_x86_64_Parser.Macro_paramContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(nasm_x86_64_Parser.COMMA)
            else:
                return self.getToken(nasm_x86_64_Parser.COMMA, i)

        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_macro_call

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMacro_call" ):
                listener.enterMacro_call(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMacro_call" ):
                listener.exitMacro_call(self)




    def macro_call(self):

        localctx = nasm_x86_64_Parser.Macro_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_macro_call)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 857
            self.name()
            self.state = 880
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [27, 30, 2612, 2613, 2615, 2616, 2617, 2618, 2622, 2626]:
                self.state = 859
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 2612)) & ~0x3f) == 0 and ((1 << (_la - 2612)) & 1147) != 0):
                    self.state = 858
                    self.macro_param()


                self.state = 865
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,86,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 861
                        self.match(nasm_x86_64_Parser.COMMA)
                        self.state = 862
                        self.macro_param() 
                    self.state = 867
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,86,self._ctx)

                pass
            elif token in [29]:
                self.state = 868
                self.match(nasm_x86_64_Parser.LEFT_PARENTHESIS)
                self.state = 870
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 2612)) & ~0x3f) == 0 and ((1 << (_la - 2612)) & 1147) != 0):
                    self.state = 869
                    self.macro_param()


                self.state = 876
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==27:
                    self.state = 872
                    self.match(nasm_x86_64_Parser.COMMA)
                    self.state = 873
                    self.macro_param()
                    self.state = 878
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 879
                self.match(nasm_x86_64_Parser.RIGHT_PARENTHESIS)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Macro_paramContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def string(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.StringContext,0)


        def name(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.NameContext,0)


        def integer(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.IntegerContext,0)


        def float_number(self):
            return self.getTypedRuleContext(nasm_x86_64_Parser.Float_numberContext,0)


        def getRuleIndex(self):
            return nasm_x86_64_Parser.RULE_macro_param

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMacro_param" ):
                listener.enterMacro_param(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMacro_param" ):
                listener.exitMacro_param(self)




    def macro_param(self):

        localctx = nasm_x86_64_Parser.Macro_paramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_macro_param)
        try:
            self.state = 886
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2618]:
                self.enterOuterAlt(localctx, 1)
                self.state = 882
                self.string()
                pass
            elif token in [2622]:
                self.enterOuterAlt(localctx, 2)
                self.state = 883
                self.name()
                pass
            elif token in [2613, 2615, 2616, 2617]:
                self.enterOuterAlt(localctx, 3)
                self.state = 884
                self.integer()
                pass
            elif token in [2612]:
                self.enterOuterAlt(localctx, 4)
                self.state = 885
                self.float_number()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





