Dataset Viewer
	| Compiler_Type
				 stringclasses 2
				values | Target
				 stringclasses 176
				values | Programming Language
				 stringclasses 3
				values | Task
				 stringclasses 4
				values | Target_Type
				 stringclasses 7
				values | Idx
				 int64 0 636k | Ground_Truth
				 sequencelengths 0 2.32k | Input
				 sequencelengths 1 1.02k | 
|---|---|---|---|---|---|---|---|
| 
	LLVM | 
	WebAssembly | 
	CPP | 
	next_suggestion | 
	Virtual ISA | 0 | 
	[
  "}"
] | 
	[
  "void",
  "Block",
  "::",
  "AddBranchTo",
  "(",
  "Block",
  "*",
  "Target",
  ",",
  "const",
  "char",
  "*",
  "Condition",
  ",",
  "const",
  "char",
  "*",
  "Code",
  ")",
  "{",
  "assert",
  "(",
  "!",
  "contains",
  "(",
  "BranchesOut",
  ",",
  "Target",
  ")",
  "&&",
  "<STR_LIT>",
  "cannot add more than one branch to the same target",
  "<STR_LIT>",
  ")",
  ";",
  "BranchesOut",
  "[",
  "Target",
  "]",
  "=",
  "make_unique",
  "<",
  "Branch",
  ">",
  "(",
  "Condition",
  ",",
  "Code",
  ")",
  ";"
] | 
| 
	GCC | 
	i386 | 
	CPP | 
	stmt_completion | 
	CPU | 1 | 
	[
  "_",
  "_",
  "mmask16",
  ")",
  "_",
  "_",
  "U",
  ")",
  ";"
] | 
	[
  "extern",
  "_",
  "_",
  "inline",
  "_",
  "_",
  "m512i",
  "_",
  "_",
  "attribute__",
  "(",
  "(",
  "_",
  "_",
  "gnu_inline__",
  ",",
  "_",
  "_",
  "always_inline__",
  ",",
  "_",
  "_",
  "artificial__",
  ")",
  ")",
  "_",
  "mm512_maskz_cvtepi8_epi32",
  "(",
  "_",
  "_",
  "mmask16",
  "_",
  "_",
  "U",
  ",",
  "_",
  "_",
  "m128i",
  "_",
  "_",
  "A",
  ")",
  "{",
  "return",
  "(",
  "_",
  "_",
  "m512i",
  ")",
  "_",
  "_",
  "builtin_ia32_pmovsxbd512_mask",
  "(",
  "(",
  "_",
  "_",
  "v16qi",
  ")",
  "_",
  "_",
  "A",
  ",",
  "(",
  "_",
  "_",
  "v16si",
  ")",
  "_",
  "mm512_setzero_si512",
  "(",
  ")",
  ",",
  "("
] | 
| 
	LLVM | 
	PowerPC | 
	TD | 
	stmt_completion | 
	CPU | 2 | 
	[
  "(",
  "PPCvecinsert",
  "v4i32",
  ":",
  "$",
  "XTi",
  ",",
  "v4i32",
  ":",
  "$",
  "XB",
  ",",
  "imm32SExt16",
  ":",
  "$",
  "UIM",
  ")",
  ")",
  "]",
  ">",
  ",",
  "RegConstraint",
  "<",
  "<STR_LIT>",
  ">",
  ",",
  "NoEncode",
  "<",
  "<STR_LIT>",
  ">",
  ";"
] | 
	[
  "def",
  "XXINSERTW",
  ":",
  "XX2_RD6_UIM5_RS6",
  "<",
  "<NUM_LIT>",
  ",",
  "<NUM_LIT>",
  ",",
  "(",
  "outs",
  "vsrc",
  ":",
  "$",
  "XT",
  ")",
  ",",
  "(",
  "ins",
  "vsrc",
  ":",
  "$",
  "XTi",
  ",",
  "vsrc",
  ":",
  "$",
  "XB",
  ",",
  "u4imm",
  ":",
  "$",
  "UIM",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "IIC_VecFP",
  ",",
  "[",
  "(",
  "set",
  "v4i32",
  ":",
  "$",
  "XT",
  ","
] | 
| 
	LLVM | 
	AArch64 | 
	CPP | 
	next_suggestion | 
	CPU | 3 | 
	[
  "assert",
  "(",
  "NumBytes",
  "<=",
  "FulleSizeInBytes",
  "&&",
  "<STR_LIT>",
  "Invalid fixup size!",
  "<STR_LIT>",
  ")",
  ";"
] | 
	[
  "Value",
  "=",
  "adjustFixupValue",
  "(",
  "Fixup",
  ",",
  "Target",
  ",",
  "Value",
  ",",
  "Ctx",
  ",",
  "TheTriple",
  ",",
  "IsResolved",
  ")",
  ";",
  "Value",
  "<<=",
  "Info",
  ".",
  "TargetOffset",
  ";",
  "unsigned",
  "Offset",
  "=",
  "Fixup",
  ".",
  "getOffset",
  "(",
  ")",
  ";",
  "assert",
  "(",
  "Offset",
  "+",
  "NumBytes",
  "<=",
  "Data",
  ".",
  "size",
  "(",
  ")",
  "&&",
  "<STR_LIT>",
  "Invalid fixup offset!",
  "<STR_LIT>",
  ")",
  ";",
  "unsigned",
  "FulleSizeInBytes",
  "=",
  "getFixupKindContainereSizeInBytes",
  "(",
  "Fixup",
  ".",
  "getKind",
  "(",
  ")",
  ")",
  ";",
  "if",
  "(",
  "FulleSizeInBytes",
  "==",
  "<NUM_LIT>",
  ")",
  "{",
  "for",
  "(",
  "unsigned",
  "i",
  "=",
  "<NUM_LIT>",
  ";",
  "i",
  "!=",
  "NumBytes",
  ";",
  "++",
  "i",
  ")",
  "{",
  "Data",
  "[",
  "Offset",
  "+",
  "i",
  "]",
  "|=",
  "uint8_t",
  "(",
  "(",
  "Value",
  ">>",
  "(",
  "i",
  "*",
  "<NUM_LIT>",
  ")",
  ")",
  "&",
  "<NUM_LIT>",
  ")",
  ";",
  "}",
  "}",
  "else",
  "{",
  "assert",
  "(",
  "(",
  "Offset",
  "+",
  "FulleSizeInBytes",
  ")",
  "<=",
  "Data",
  ".",
  "size",
  "(",
  ")",
  "&&",
  "<STR_LIT>",
  "Invalid fixup size!",
  "<STR_LIT>",
  ")",
  ";"
] | 
| 
	LLVM | 
	AArch64 | 
	TD | 
	next_suggestion | 
	CPU | 4 | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "target",
  ";"
] | 
	[
  "let",
  "isBranch",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "isTerminator",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Uses",
  "=",
  "[",
  "NZCV",
  "]",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "cond",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "target",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	LLVM | 
	AMDGPU | 
	CPP | 
	next_suggestion | 
	GPU | 5 | 
	[
  "if",
  "(",
  "!",
  "Info",
  "->",
  "isEntryFunction",
  "(",
  ")",
  "&&",
  "FI",
  ".",
  "hasValue",
  "(",
  ")",
  ")",
  "MIB",
  ".",
  "addReg",
  "(",
  "Info",
  "->",
  "getStackPtrOffsetReg",
  "(",
  ")",
  ")",
  ";"
] | 
	[
  "const",
  "MachineInstr",
  "*",
  "LHSDef",
  "=",
  "MRI",
  "->",
  "getVRegDef",
  "(",
  "LHS",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ";",
  "const",
  "MachineInstr",
  "*",
  "RHSDef",
  "=",
  "MRI",
  "->",
  "getVRegDef",
  "(",
  "RHS",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ";",
  "if",
  "(",
  "LHSDef",
  "&&",
  "RHSDef",
  ")",
  "{",
  "int64_t",
  "PossibleOffset",
  "=",
  "RHSDef",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ".",
  "getCImm",
  "(",
  ")",
  "->",
  "getSExtValue",
  "(",
  ")",
  ";",
  "if",
  "(",
  "SIInstrInfo",
  "::",
  "isLegalMUBUFImmOffset",
  "(",
  "PossibleOffset",
  ")",
  "&&",
  "(",
  "!",
  "STI",
  ".",
  "privateMemoryResourceIsRangeChecked",
  "(",
  ")",
  "||",
  "KnownBits",
  "->",
  "signBitIsZero",
  "(",
  "LHS",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ")",
  ")",
  "{",
  "if",
  "(",
  "LHSDef",
  "->",
  "getOpcode",
  "(",
  ")",
  "==",
  "AMDGPU",
  "::",
  "G_FRAME_INDEX",
  ")",
  "FI",
  "=",
  "LHSDef",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ".",
  "getIndex",
  "(",
  ")",
  ";",
  "else",
  "VAddr",
  "=",
  "LHS",
  ".",
  "getReg",
  "(",
  ")",
  ";",
  "Offset",
  "=",
  "PossibleOffset",
  ";",
  "}",
  "}",
  "}",
  "else",
  "if",
  "(",
  "RootDef",
  "->",
  "getOpcode",
  "(",
  ")",
  "==",
  "AMDGPU",
  "::",
  "G_FRAME_INDEX",
  ")",
  "{",
  "FI",
  "=",
  "RootDef",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ".",
  "getIndex",
  "(",
  ")",
  ";",
  "}",
  "}",
  "return",
  "{",
  "{",
  "[",
  "=",
  "]",
  "(",
  "MachineInstrBuilder",
  "&",
  "MIB",
  ")",
  "{",
  "MIB",
  ".",
  "addReg",
  "(",
  "Info",
  "->",
  "getScratchRSrcReg",
  "(",
  ")",
  ")",
  ";",
  "}",
  ",",
  "[",
  "=",
  "]",
  "(",
  "MachineInstrBuilder",
  "&",
  "MIB",
  ")",
  "{",
  "if",
  "(",
  "FI",
  ".",
  "hasValue",
  "(",
  ")",
  ")",
  "MIB",
  ".",
  "addFrameIndex",
  "(",
  "FI",
  ".",
  "getValue",
  "(",
  ")",
  ")",
  ";",
  "else",
  "MIB",
  ".",
  "addReg",
  "(",
  "VAddr",
  ")",
  ";",
  "}",
  ",",
  "[",
  "=",
  "]",
  "(",
  "MachineInstrBuilder",
  "&",
  "MIB",
  ")",
  "{"
] | 
| 
	GCC | 
	iq2000 | 
	CPP | 
	code_generation | 
	CPU | 6 | 
	[
  "static",
  "section",
  "*",
  "iq2000_select_rtx_section",
  "(",
  "machine_mode",
  "mode",
  ",",
  "rtx",
  "x",
  "ATTRIBUTE_UNUSED",
  ",",
  "unsigned",
  "HOST_WIDE_INT",
  "align",
  ")",
  "{",
  "return",
  "mergeable_constant_section",
  "(",
  "mode",
  ",",
  "align",
  ",",
  "<NUM_LIT>",
  ")",
  ";",
  "}"
] | 
	[
  "Choose",
  "the",
  "section",
  "to",
  "use",
  "for",
  "the",
  "constant",
  "rtx",
  "expression",
  "X",
  "that",
  "has",
  "mode",
  "MODE",
  "."
] | 
| 
	GCC | 
	aarch64 | 
	CPP | 
	next_suggestion | 
	CPU | 7 | 
	[
  "}"
] | 
	[
  "static",
  "tree",
  "add_attribute",
  "(",
  "const",
  "char",
  "*",
  "name",
  ",",
  "tree",
  "attrs",
  ")",
  "{",
  "return",
  "tree_cons",
  "(",
  "get_identifier",
  "(",
  "name",
  ")",
  ",",
  "NULL_TREE",
  ",",
  "attrs",
  ")",
  ";"
] | 
| 
	LLVM | 
	SystemZ | 
	TD | 
	next_suggestion | 
	CPU | 8 | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "V2",
  "{",
  "<NUM_LIT>",
  "}",
  ";"
] | 
	[
  "field",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Inst",
  ";",
  "field",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "SoftFail",
  "=",
  "<NUM_LIT>",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "V1",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "V2",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "M3",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "M4",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "M5",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "op",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "V1",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "V2",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "M5",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "!",
  "if",
  "(",
  "!",
  "eq",
  "(",
  "m4or",
  "{",
  "<NUM_LIT>",
  "}",
  ",",
  "<NUM_LIT>",
  ")",
  ",",
  "<NUM_LIT>",
  ",",
  "M4",
  "{",
  "<NUM_LIT>",
  "}",
  ")",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "!",
  "if",
  "(",
  "!",
  "eq",
  "(",
  "m4or",
  "{",
  "<NUM_LIT>",
  "}",
  ",",
  "<NUM_LIT>",
  ")",
  ",",
  "<NUM_LIT>",
  ",",
  "M4",
  "{",
  "<NUM_LIT>",
  "}",
  ")",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "!",
  "if",
  "(",
  "!",
  "eq",
  "(",
  "m4or",
  "{",
  "<NUM_LIT>",
  "}",
  ",",
  "<NUM_LIT>",
  ")",
  ",",
  "<NUM_LIT>",
  ",",
  "M4",
  "{",
  "<NUM_LIT>",
  "}",
  ")",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "!",
  "if",
  "(",
  "!",
  "eq",
  "(",
  "m4or",
  "{",
  "<NUM_LIT>",
  "}",
  ",",
  "<NUM_LIT>",
  ")",
  ",",
  "<NUM_LIT>",
  ",",
  "M4",
  "{",
  "<NUM_LIT>",
  "}",
  ")",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "M3",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "V1",
  "{",
  "<NUM_LIT>",
  "}",
  ";"
] | 
| 
	GCC | 
	sh | 
	MD | 
	program_repair | 
	CPU | 9 | 
	[
  "<FIXS>",
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "<FIXE>",
  "<FIXS>",
  "(",
  "use",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  "(",
  "use",
  "(",
  "match_operand",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  "<FIXE>",
  "<FIXS>",
  "<STR_LIT>",
  "<FIXE>",
  "<FIXS>",
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "<FIXE>",
  "<FIXS>",
  "(",
  "use",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  "(",
  "use",
  "(",
  "match_operand",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  "]",
  "<FIXE>",
  "<FIXS>",
  "<STR_LIT>",
  "<FIXE>"
] | 
	[
  "}",
  ")",
  "(",
  "define_insn",
  "<STR_LIT>",
  "<BUGS>",
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "<BUGE>",
  "(",
  "div",
  ":",
  "SI",
  "(",
  "reg",
  ":",
  "SI",
  "R4_REG",
  ")",
  "(",
  "reg",
  ":",
  "SI",
  "R5_REG",
  ")",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "SI",
  "PR_REG",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "DF",
  "DR0_REG",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "DF",
  "DR2_REG",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "SI",
  "FPSCR_STAT_REG",
  ")",
  ")",
  "<BUGS>",
  "(",
  "use",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  "<BUGE>",
  "(",
  "use",
  "(",
  "reg",
  ":",
  "SI",
  "FPSCR_MODES_REG",
  ")",
  ")",
  "]",
  "<STR_LIT>",
  "<BUGS>",
  "<STR_LIT>",
  "<BUGE>",
  "[",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "]",
  ")",
  "(",
  "define_insn",
  "<STR_LIT>",
  "<BUGS>",
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "<BUGE>",
  "(",
  "div",
  ":",
  "SI",
  "(",
  "reg",
  ":",
  "SI",
  "R4_REG",
  ")",
  "(",
  "reg",
  ":",
  "SI",
  "R5_REG",
  ")",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "SI",
  "PR_REG",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "DF",
  "DR0_REG",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "DF",
  "DR2_REG",
  ")",
  ")",
  "(",
  "clobber",
  "(",
  "reg",
  ":",
  "SI",
  "R2_REG",
  ")",
  ")",
  "<BUGS>",
  "(",
  "use",
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  "]",
  "<BUGE>",
  "<STR_LIT>",
  "<BUGS>",
  "<STR_LIT>",
  "<BUGE>",
  "[",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "]",
  ")"
] | 
| 
	LLVM | 
	X86 | 
	TD | 
	stmt_completion | 
	CPU | 10 | 
	[
  ":",
  "$",
  "ptr",
  ")",
  ")",
  ">",
  ";"
] | 
	[
  "def",
  "extloadi64i32",
  ":",
  "PatFrag",
  "<",
  "(",
  "ops",
  "node",
  ":",
  "$",
  "ptr",
  ")",
  ",",
  "(",
  "i64",
  "(",
  "extloadi32",
  "node"
] | 
| 
	LLVM | 
	AMDGPU | 
	CPP | 
	stmt_completion | 
	GPU | 11 | 
	[
  ":",
  "<NUM_LIT>",
  ";"
] | 
	[
  "auto",
  "Arg",
  "=",
  "ArgInfo",
  ".",
  "getPreloadedValue",
  "(",
  "Value",
  ")",
  ".",
  "first",
  ";",
  "return",
  "Arg",
  "?",
  "Arg",
  "->",
  "getRegister",
  "(",
  ")"
] | 
| 
	GCC | 
	i386 | 
	MD | 
	next_suggestion | 
	CPU | 12 | 
	[
  "<STR_LIT>",
  ")"
] | 
	[
  "(",
  "define_insn_reservation",
  "<STR_LIT>",
  "<NUM_LIT>",
  "(",
  "and",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "and",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "and",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  ")",
  ")"
] | 
| 
	LLVM | 
	AArch64 | 
	TD | 
	next_suggestion | 
	CPU | 13 | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Zd",
  ";"
] | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "sz8_64",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Zm",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Zn",
  ";"
] | 
| 
	GCC | 
	i386 | 
	MD | 
	program_repair | 
	CPU | 14 | 
	[
  "<FIXS>",
  "(",
  "V2DI",
  "<STR_LIT>",
  ")",
  "(",
  "V4DI",
  "<STR_LIT>",
  ")",
  "(",
  "V8DI",
  "<STR_LIT>",
  ")",
  "]",
  ")",
  "<FIXE>"
] | 
	[
  "[",
  "(",
  "V16QI",
  "<STR_LIT>",
  ")",
  "(",
  "V32QI",
  "<STR_LIT>",
  ")",
  "(",
  "V8HI",
  "<STR_LIT>",
  ")",
  "(",
  "V16HI",
  "<STR_LIT>",
  ")",
  "(",
  "V4SI",
  "<STR_LIT>",
  ")",
  "(",
  "V8SI",
  "<STR_LIT>",
  ")",
  "(",
  "V16SI",
  "<STR_LIT>",
  ")",
  "<BUGS>",
  "(",
  "V2DI",
  "<STR_LIT>",
  ")",
  "(",
  "V4DI",
  "<STR_LIT>",
  ")",
  "]",
  ")",
  "<BUGE>",
  "(",
  "define_mode_attr",
  "avx_avx2",
  "[",
  "(",
  "V4SF",
  "<STR_LIT>",
  ")",
  "(",
  "V2DF",
  "<STR_LIT>",
  ")"
] | 
| 
	LLVM | 
	AArch64 | 
	CPP | 
	stmt_completion | 
	CPU | 15 | 
	[
  ")",
  ";"
] | 
	[
  "if",
  "(",
  "Value",
  "&",
  "<NUM_LIT>",
  ")",
  "Ctx",
  ".",
  "reportError",
  "(",
  "Fixup",
  ".",
  "getLoc",
  "(",
  ")",
  ",",
  "<STR_LIT>",
  "fixup must be 16-byte aligned",
  "<STR_LIT>",
  ")",
  ";",
  "return",
  "Value",
  ">>",
  "<NUM_LIT>",
  ";",
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":",
  "{",
  "AArch64MCExpr",
  "::",
  "VariantKind",
  "RefKind",
  "=",
  "static_cast",
  "<",
  "AArch64MCExpr",
  "::",
  "VariantKind",
  ">",
  "(",
  "Target",
  ".",
  "getRefKind",
  "(",
  ")",
  ")",
  ";",
  "if",
  "(",
  "AArch64MCExpr",
  "::",
  "getSymbolLoc",
  "(",
  "RefKind",
  ")",
  "!=",
  "AArch64MCExpr",
  "::",
  "VK_ABS",
  "&&",
  "AArch64MCExpr",
  "::",
  "getSymbolLoc",
  "(",
  "RefKind",
  ")",
  "!=",
  "AArch64MCExpr",
  "::",
  "VK_SABS",
  ")",
  "{",
  "Ctx",
  ".",
  "reportError",
  "(",
  "Fixup",
  ".",
  "getLoc",
  "(",
  ")",
  ",",
  "<STR_LIT>",
  "relocation for a thread-local variable points to an ",
  "<STR_LIT>",
  "<STR_LIT>",
  "absolute symbol",
  "<STR_LIT>",
  ")",
  ";",
  "return",
  "Value",
  ";",
  "}",
  "if",
  "(",
  "!",
  "IsResolved",
  ")",
  "{",
  "Ctx",
  ".",
  "reportError",
  "(",
  "Fixup",
  ".",
  "getLoc",
  "(",
  ")",
  ",",
  "<STR_LIT>",
  "unresolved movw fixup not yet ",
  "<STR_LIT>",
  "<STR_LIT>",
  "implemented",
  "<STR_LIT>",
  ")",
  ";",
  "return",
  "Value",
  ";",
  "}",
  "if",
  "(",
  "AArch64MCExpr",
  "::",
  "getSymbolLoc",
  "(",
  "RefKind",
  ")",
  "==",
  "AArch64MCExpr",
  "::",
  "VK_SABS",
  ")",
  "{",
  "switch",
  "(",
  "AArch64MCExpr",
  "::",
  "getAddressFrag",
  "(",
  "RefKind",
  ")",
  ")",
  "{",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G0",
  ":",
  "break",
  ";",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G1",
  ":",
  "SignedValue",
  "=",
  "SignedValue",
  ">>",
  "<NUM_LIT>",
  ";",
  "break",
  ";",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G2",
  ":",
  "SignedValue",
  "=",
  "SignedValue",
  ">>",
  "<NUM_LIT>",
  ";",
  "break",
  ";",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G3",
  ":",
  "SignedValue",
  "=",
  "SignedValue",
  ">>",
  "<NUM_LIT>",
  ";",
  "break",
  ";",
  "default",
  ":",
  "llvm_unreachable",
  "(",
  "<STR_LIT>",
  "Variant kind doesn't correspond to fixup",
  "<STR_LIT>",
  ")",
  ";",
  "}",
  "}",
  "else",
  "{",
  "switch",
  "(",
  "AArch64MCExpr",
  "::",
  "getAddressFrag",
  "(",
  "RefKind",
  ")",
  ")",
  "{",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G0",
  ":",
  "break",
  ";",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G1",
  ":",
  "Value",
  "=",
  "Value",
  ">>",
  "<NUM_LIT>",
  ";",
  "break",
  ";",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G2",
  ":",
  "Value",
  "=",
  "Value",
  ">>",
  "<NUM_LIT>",
  ";",
  "break",
  ";",
  "case",
  "AArch64MCExpr",
  "::",
  "VK_G3",
  ":",
  "Value",
  "=",
  "Value",
  ">>",
  "<NUM_LIT>",
  ";",
  "break",
  ";",
  "default",
  ":",
  "llvm_unreachable",
  "(",
  "<STR_LIT>",
  "Variant kind doesn't correspond to fixup",
  "<STR_LIT>",
  ")",
  ";",
  "}",
  "}",
  "if",
  "(",
  "RefKind",
  "&",
  "AArch64MCExpr",
  "::",
  "VK_NC",
  ")",
  "{",
  "Value",
  "&=",
  "<NUM_LIT>",
  ";",
  "}",
  "else",
  "if",
  "(",
  "AArch64MCExpr",
  "::",
  "getSymbolLoc",
  "(",
  "RefKind",
  ")",
  "==",
  "AArch64MCExpr",
  "::",
  "VK_SABS",
  ")",
  "{",
  "if",
  "(",
  "SignedValue",
  ">",
  "<NUM_LIT>",
  "||",
  "SignedValue",
  "<",
  "-",
  "<NUM_LIT>",
  ")",
  "Ctx",
  ".",
  "reportError",
  "(",
  "Fixup",
  ".",
  "getLoc",
  "(",
  ")",
  ",",
  "<STR_LIT>",
  "fixup value out of range",
  "<STR_LIT>",
  ")",
  ";",
  "if",
  "(",
  "SignedValue",
  "<",
  "<NUM_LIT>",
  ")",
  "SignedValue",
  "=",
  "~",
  "SignedValue",
  ";",
  "Value",
  "=",
  "static_cast",
  "<",
  "uint64_t",
  ">",
  "(",
  "SignedValue"
] | 
| 
	LLVM | 
	BPF | 
	CPP | 
	next_suggestion | 
	Virtual ISA | 16 | 
	[
  "initializeBPFMIPeepholeTruncElimPass",
  "(",
  "PR",
  ")",
  ";"
] | 
	[
  "PassRegistry",
  "&",
  "PR",
  "=",
  "*",
  "PassRegistry",
  "::",
  "getPassRegistry",
  "(",
  ")",
  ";",
  "initializeBPFAbstractMemberAccessPass",
  "(",
  "PR",
  ")",
  ";",
  "initializeBPFPreserveDITypePass",
  "(",
  "PR",
  ")",
  ";",
  "initializeBPFMIPeepholePass",
  "(",
  "PR",
  ")",
  ";"
] | 
| 
	GCC | 
	mips | 
	MD | 
	stmt_completion | 
	CPU | 17 | 
	[
  ")",
  "]",
  ")"
] | 
	[
  "(",
  "define_insn",
  "<STR_LIT>",
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "ANYF",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "fma",
  ":",
  "ANYF",
  "(",
  "match_operand",
  ":",
  "ANYF",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "match_operand",
  ":",
  "ANYF",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "match_operand",
  ":",
  "ANYF",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  ")",
  "]",
  "<STR_LIT>",
  "<STR_LIT>",
  "[",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>"
] | 
| 
	LLVM | 
	ARM | 
	CPP | 
	next_suggestion | 
	CPU | 18 | 
	[
  "if",
  "(",
  "Scale",
  ">",
  "<NUM_LIT>",
  ")",
  "O",
  "<<",
  "<STR_LIT>",
  " * ",
  "<STR_LIT>",
  "<<",
  "Scale",
  ";"
] | 
	[
  "}",
  "O",
  "<<",
  "<STR_LIT>",
  "[",
  "<STR_LIT>",
  "<<",
  "TRI",
  "->",
  "getAsmName",
  "(",
  "MO1",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ";",
  "if",
  "(",
  "MO3",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  "O",
  "<<",
  "<STR_LIT>",
  ", ",
  "<STR_LIT>",
  "<<",
  "TRI",
  "->",
  "getAsmName",
  "(",
  "MO3",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ";",
  "else",
  "if",
  "(",
  "unsigned",
  "ImmOffs",
  "=",
  "MO2",
  ".",
  "getImm",
  "(",
  ")",
  ")",
  "{",
  "O",
  "<<",
  "<STR_LIT>",
  ", #",
  "<STR_LIT>",
  "<<",
  "ImmOffs",
  ";"
] | 
| 
	LLVM | 
	AArch64 | 
	TD | 
	next_suggestion | 
	CPU | 19 | 
	[
  "}"
] | 
	[
  "def",
  "roW",
  ":",
  "LoadStore8RO",
  "<",
  "sz",
  ",",
  "V",
  ",",
  "opc",
  ",",
  "asm",
  ",",
  "(",
  "outs",
  "regtype",
  ":",
  "$",
  "Rt",
  ")",
  ",",
  "(",
  "ins",
  "GPR64sp",
  ":",
  "$",
  "Rn",
  ",",
  "GPR32",
  ":",
  "$",
  "Rm",
  ",",
  "ro_Wextend8",
  ":",
  "$",
  "extend",
  ")",
  ",",
  "[",
  "(",
  "set",
  "(",
  "Ty",
  "regtype",
  ":",
  "$",
  "Rt",
  ")",
  ",",
  "(",
  "loadop",
  "(",
  "ro_Windexed8",
  "GPR64sp",
  ":",
  "$",
  "Rn",
  ",",
  "GPR32",
  ":",
  "$",
  "Rm",
  ",",
  "ro_Wextend8",
  ":",
  "$",
  "extend",
  ")",
  ")",
  ")",
  "]",
  ">",
  ",",
  "Sched",
  "<",
  "[",
  "WriteLDIdx",
  ",",
  "ReadAdrBase",
  "]",
  ">",
  "{",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	LLVM | 
	ARM | 
	CPP | 
	stmt_completion | 
	CPU | 20 | 
	[
  ":"
] | 
	[
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "break",
  ";",
  "case",
  "ARM",
  "::",
  "FK_VFPV3_FP16",
  ":",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "break",
  ";",
  "case",
  "ARM",
  "::",
  "FK_VFPV3_D16",
  ":",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "break",
  ";",
  "case",
  "ARM",
  "::",
  "FK_VFPV3_D16_FP16",
  ":",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "break",
  ";",
  "case",
  "ARM",
  "::",
  "FK_VFPV3XD",
  ":",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "break",
  ";",
  "case",
  "ARM",
  "::",
  "FK_VFPV3XD_FP16",
  ":",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "setAttributeItem",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "false",
  ")",
  ";",
  "break",
  ";",
  "case",
  "ARM",
  "::",
  "FK_VFPV4"
] | 
| 
	LLVM | 
	SNES | 
	TD | 
	stmt_completion | 
	DSP | 21 | 
	[
  "src",
  ",",
  "imm",
  ":",
  "$",
  "k",
  ")",
  ")",
  ",",
  "(",
  "implicit",
  "P",
  ")",
  "]",
  ">",
  ";"
] | 
	[
  "def",
  "SBCIRdK",
  ":",
  "FRdK",
  "<",
  "<NUM_LIT>",
  ",",
  "(",
  "outs",
  "MainRegs",
  ":",
  "$",
  "rd",
  ")",
  ",",
  "(",
  "ins",
  "MainRegs",
  ":",
  "$",
  "src",
  ",",
  "imm_ldi16",
  ":",
  "$",
  "k",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "[",
  "(",
  "set",
  "i16",
  ":",
  "$",
  "rd",
  ",",
  "(",
  "sube",
  "i16",
  ":",
  "$"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	stmt_completion | 
	DSP | 22 | 
	[
  "=",
  "<NUM_LIT>",
  ";"
] | 
	[
  "def",
  "L2_loadrub_io",
  ":",
  "HInst",
  "<",
  "(",
  "outs",
  "IntRegs",
  ":",
  "$",
  "Rd32",
  ")",
  ",",
  "(",
  "ins",
  "IntRegs",
  ":",
  "$",
  "Rs32",
  ",",
  "s32_0Imm",
  ":",
  "$",
  "Ii",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "tc_17e0d2cd",
  ",",
  "TypeLD",
  ">",
  ",",
  "Enc_211aaa",
  ",",
  "AddrModeRel",
  ",",
  "PostInc_BaseImm",
  "{",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "hasNewValue",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "opNewValue",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "addrMode",
  "=",
  "BaseImmOffset",
  ";",
  "let",
  "accessSize",
  "=",
  "ByteAccess",
  ";",
  "let",
  "mayLoad"
] | 
| 
	GCC | 
	fr30 | 
	MD | 
	next_suggestion | 
	DSP | 23 | 
	[
  "<STR_LIT>"
] | 
	[
  "(",
  "match_operand",
  ":",
  "SI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")",
  ")",
  "]",
  "<STR_LIT>"
] | 
| 
	GCC | 
	i386 | 
	CPP | 
	next_suggestion | 
	CPU | 24 | 
	[
  "pic_reg_used",
  "=",
  "true",
  ";"
] | 
	[
  "x",
  "=",
  "gen_rtx_EXPR_LIST",
  "(",
  "REG_FRAME_RELATED_EXPR",
  ",",
  "x",
  ",",
  "NULL",
  ")",
  ";",
  "REG_NOTES",
  "(",
  "insn",
  ")",
  "=",
  "x",
  ";",
  "}",
  "if",
  "(",
  "frame_pointer_needed",
  ")",
  "{",
  "insn",
  "=",
  "emit_insn",
  "(",
  "gen_push",
  "(",
  "hard_frame_pointer_rtx",
  ")",
  ")",
  ";",
  "RTX_FRAME_RELATED_P",
  "(",
  "insn",
  ")",
  "=",
  "<NUM_LIT>",
  ";",
  "insn",
  "=",
  "emit_move_insn",
  "(",
  "hard_frame_pointer_rtx",
  ",",
  "stack_pointer_rtx",
  ")",
  ";",
  "RTX_FRAME_RELATED_P",
  "(",
  "insn",
  ")",
  "=",
  "<NUM_LIT>",
  ";",
  "}",
  "allocate",
  "=",
  "frame",
  ".",
  "to_allocate",
  ";",
  "if",
  "(",
  "!",
  "frame",
  ".",
  "save_regs_using_mov",
  ")",
  "ix86_emit_save_regs",
  "(",
  ")",
  ";",
  "else",
  "allocate",
  "+=",
  "frame",
  ".",
  "nregs",
  "*",
  "UNITS_PER_WORD",
  ";",
  "if",
  "(",
  "TARGET_RED_ZONE",
  "&&",
  "frame",
  ".",
  "save_regs_using_mov",
  ")",
  "ix86_emit_save_regs_using_mov",
  "(",
  "frame_pointer_needed",
  "?",
  "hard_frame_pointer_rtx",
  ":",
  "stack_pointer_rtx",
  ",",
  "-",
  "frame",
  ".",
  "nregs",
  "*",
  "UNITS_PER_WORD",
  ")",
  ";",
  "if",
  "(",
  "allocate",
  "==",
  "<NUM_LIT>",
  ")",
  ";",
  "else",
  "if",
  "(",
  "!",
  "TARGET_STACK_PROBE",
  "||",
  "allocate",
  "<",
  "CHECK_STACK_LIMIT",
  ")",
  "pro_epilogue_adjust_stack",
  "(",
  "stack_pointer_rtx",
  ",",
  "stack_pointer_rtx",
  ",",
  "GEN_INT",
  "(",
  "-",
  "allocate",
  ")",
  ",",
  "-",
  "<NUM_LIT>",
  ")",
  ";",
  "else",
  "{",
  "rtx",
  "eax",
  "=",
  "gen_rtx_REG",
  "(",
  "SImode",
  ",",
  "<NUM_LIT>",
  ")",
  ";",
  "bool",
  "eax_live",
  "=",
  "ix86_eax_live_at_start_p",
  "(",
  ")",
  ";",
  "rtx",
  "t",
  ";",
  "gcc_assert",
  "(",
  "!",
  "TARGET_64BIT",
  ")",
  ";",
  "if",
  "(",
  "eax_live",
  ")",
  "{",
  "emit_insn",
  "(",
  "gen_push",
  "(",
  "eax",
  ")",
  ")",
  ";",
  "allocate",
  "-=",
  "<NUM_LIT>",
  ";",
  "}",
  "emit_move_insn",
  "(",
  "eax",
  ",",
  "GEN_INT",
  "(",
  "allocate",
  ")",
  ")",
  ";",
  "insn",
  "=",
  "emit_insn",
  "(",
  "gen_allocate_stack_worker",
  "(",
  "eax",
  ")",
  ")",
  ";",
  "RTX_FRAME_RELATED_P",
  "(",
  "insn",
  ")",
  "=",
  "<NUM_LIT>",
  ";",
  "t",
  "=",
  "gen_rtx_PLUS",
  "(",
  "Pmode",
  ",",
  "stack_pointer_rtx",
  ",",
  "GEN_INT",
  "(",
  "-",
  "allocate",
  ")",
  ")",
  ";",
  "t",
  "=",
  "gen_rtx_SET",
  "(",
  "VOIDmode",
  ",",
  "stack_pointer_rtx",
  ",",
  "t",
  ")",
  ";",
  "REG_NOTES",
  "(",
  "insn",
  ")",
  "=",
  "gen_rtx_EXPR_LIST",
  "(",
  "REG_FRAME_RELATED_EXPR",
  ",",
  "t",
  ",",
  "REG_NOTES",
  "(",
  "insn",
  ")",
  ")",
  ";",
  "if",
  "(",
  "eax_live",
  ")",
  "{",
  "if",
  "(",
  "frame_pointer_needed",
  ")",
  "t",
  "=",
  "plus_constant",
  "(",
  "hard_frame_pointer_rtx",
  ",",
  "allocate",
  "-",
  "frame",
  ".",
  "to_allocate",
  "-",
  "frame",
  ".",
  "nregs",
  "*",
  "UNITS_PER_WORD",
  ")",
  ";",
  "else",
  "t",
  "=",
  "plus_constant",
  "(",
  "stack_pointer_rtx",
  ",",
  "allocate",
  ")",
  ";",
  "emit_move_insn",
  "(",
  "eax",
  ",",
  "gen_rtx_MEM",
  "(",
  "SImode",
  ",",
  "t",
  ")",
  ")",
  ";",
  "}",
  "}",
  "if",
  "(",
  "frame",
  ".",
  "save_regs_using_mov",
  "&&",
  "!",
  "TARGET_RED_ZONE",
  ")",
  "{",
  "if",
  "(",
  "!",
  "frame_pointer_needed",
  "||",
  "!",
  "frame",
  ".",
  "to_allocate",
  ")",
  "ix86_emit_save_regs_using_mov",
  "(",
  "stack_pointer_rtx",
  ",",
  "frame",
  ".",
  "to_allocate",
  ")",
  ";",
  "else",
  "ix86_emit_save_regs_using_mov",
  "(",
  "hard_frame_pointer_rtx",
  ",",
  "-",
  "frame",
  ".",
  "nregs",
  "*",
  "UNITS_PER_WORD",
  ")",
  ";",
  "}",
  "pic_reg_used",
  "=",
  "false",
  ";",
  "if",
  "(",
  "pic_offset_table_rtx",
  "&&",
  "(",
  "regs_ever_live",
  "[",
  "REAL_PIC_OFFSET_TABLE_REGNUM",
  "]",
  "||",
  "current_function_profile",
  ")",
  ")",
  "{",
  "unsigned",
  "int",
  "alt_pic_reg_used",
  "=",
  "ix86_select_alt_pic_regnum",
  "(",
  ")",
  ";",
  "if",
  "(",
  "alt_pic_reg_used",
  "!=",
  "INVALID_REGNUM",
  ")",
  "REGNO",
  "(",
  "pic_offset_table_rtx",
  ")",
  "=",
  "alt_pic_reg_used",
  ";"
] | 
| 
	GCC | 
	mips | 
	MD | 
	next_suggestion | 
	CPU | 25 | 
	[
  "<STR_LIT>",
  ")"
] | 
	[
  "(",
  "define_insn_reservation",
  "<STR_LIT>",
  "<NUM_LIT>",
  "(",
  "and",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")"
] | 
| 
	LLVM | 
	WebAssembly | 
	CPP | 
	next_suggestion | 
	Virtual ISA | 26 | 
	[
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_SUB_I64_S",
  ":"
] | 
	[
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD8_U_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD8_U_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD8_U_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE8_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE8_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE8_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE8_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE8_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE8_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE8_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE8_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_ADD_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_ADD_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_ADD_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_ADD_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_SUB_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_SUB_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_SUB_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_SUB_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_AND_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_AND_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_AND_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_AND_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_OR_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_OR_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_OR_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_OR_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XOR_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XOR_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XOR_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XOR_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XCHG_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XCHG_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XCHG_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW8_U_XCHG_I64_S",
  ":",
  "return",
  "<NUM_LIT>",
  ";",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_S_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_S_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_U_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_U_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_S_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_S_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_U_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD16_U_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD16_U_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD16_U_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD16_U_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD16_U_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE16_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE16_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE16_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE16_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE16_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE16_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE16_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE16_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_ADD_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_ADD_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_ADD_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_ADD_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_SUB_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_SUB_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_SUB_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_SUB_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_AND_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_AND_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_AND_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_AND_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_OR_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_OR_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_OR_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_OR_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XOR_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XOR_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XOR_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XOR_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XCHG_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XCHG_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XCHG_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW16_U_XCHG_I64_S",
  ":",
  "return",
  "<NUM_LIT>",
  ";",
  "case",
  "WebAssembly",
  "::",
  "LOAD_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD_F32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD_F32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_F32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_F32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD32_S_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD32_S_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD32_U_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD32_U_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE32_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE32_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD32_U_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD32_U_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE32_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE32_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_ADD_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_ADD_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_ADD_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_ADD_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_SUB_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_SUB_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_SUB_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_SUB_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_AND_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_AND_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_AND_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_AND_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_OR_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_OR_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_OR_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_OR_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_XOR_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_XOR_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_XOR_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_XOR_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_XCHG_I32",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_XCHG_I32_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_XCHG_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW32_U_XCHG_I64_S",
  ":",
  "return",
  "<NUM_LIT>",
  ";",
  "case",
  "WebAssembly",
  "::",
  "LOAD_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD_F64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "LOAD_F64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_F64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "STORE_F64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_LOAD_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_STORE_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_ADD_I64",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_ADD_I64_S",
  ":",
  "case",
  "WebAssembly",
  "::",
  "ATOMIC_RMW_SUB_I64",
  ":"
] | 
| 
	LLVM | 
	X86 | 
	CPP | 
	stmt_completion | 
	CPU | 27 | 
	[
  "N",
  ")",
  ";"
] | 
	[
  "assert",
  "(",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  "==",
  "N",
  "->",
  "getOpcode",
  "(",
  ")",
  "||",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  "==",
  "N",
  "->",
  "getOpcode",
  "(",
  ")",
  "||",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  "==",
  "N",
  "->",
  "getOpcode",
  "(",
  ")",
  "||",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  "==",
  "N",
  "->",
  "getOpcode",
  "(",
  ")",
  ")",
  "&&",
  "<STR_LIT>",
  "Unexpected horizontal add/sub opcode",
  "<STR_LIT>",
  ")",
  ";",
  "if",
  "(",
  "!",
  "shouldUseHorizontalOp",
  "(",
  "true",
  ",",
  "DAG",
  ",",
  "Subtarget",
  ")",
  ")",
  "{",
  "MVT",
  "VT",
  "=",
  "N",
  "->",
  "getSimpleValueType",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "SDValue",
  "LHS",
  "=",
  "N",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "SDValue",
  "RHS",
  "=",
  "N",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "if",
  "(",
  "LHS",
  "!=",
  "RHS",
  "&&",
  "LHS",
  ".",
  "getOpcode",
  "(",
  ")",
  "==",
  "N",
  "->",
  "getOpcode",
  "(",
  ")",
  "&&",
  "LHS",
  ".",
  "getOpcode",
  "(",
  ")",
  "==",
  "RHS",
  ".",
  "getOpcode",
  "(",
  ")",
  "&&",
  "LHS",
  ".",
  "getValueType",
  "(",
  ")",
  "==",
  "RHS",
  ".",
  "getValueType",
  "(",
  ")",
  "&&",
  "N",
  "->",
  "isOnlyUserOf",
  "(",
  "LHS",
  ".",
  "getNode",
  "(",
  ")",
  ")",
  "&&",
  "N",
  "->",
  "isOnlyUserOf",
  "(",
  "RHS",
  ".",
  "getNode",
  "(",
  ")",
  ")",
  ")",
  "{",
  "SDValue",
  "LHS0",
  "=",
  "LHS",
  ".",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "SDValue",
  "LHS1",
  "=",
  "LHS",
  ".",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "SDValue",
  "RHS0",
  "=",
  "RHS",
  ".",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "SDValue",
  "RHS1",
  "=",
  "RHS",
  ".",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "if",
  "(",
  "(",
  "LHS0",
  "==",
  "LHS1",
  "||",
  "LHS0",
  ".",
  "isUndef",
  "(",
  ")",
  "||",
  "LHS1",
  ".",
  "isUndef",
  "(",
  ")",
  ")",
  "&&",
  "(",
  "RHS0",
  "==",
  "RHS1",
  "||",
  "RHS0",
  ".",
  "isUndef",
  "(",
  ")",
  "||",
  "RHS1",
  ".",
  "isUndef",
  "(",
  ")",
  ")",
  ")",
  "{",
  "SDLoc",
  "DL",
  "("
] | 
| 
	LLVM | 
	SPIRV | 
	CPP | 
	stmt_completion | 
	Virtual ISA | 28 | 
	[
  ")",
  ";"
] | 
	[
  "BitVector",
  "Reserved",
  "(",
  "getNumRegs",
  "(",
  ")"
] | 
| 
	LLVM | 
	ARM | 
	TD | 
	stmt_completion | 
	CPU | 29 | 
	[
  "]",
  ">",
  ";"
] | 
	[
  "def",
  "VST4d16Pseudo",
  ":",
  "VSTQQPseudo",
  "<",
  "IIC_VST4",
  ">",
  ",",
  "Sched",
  "<",
  "[",
  "WriteVST4"
] | 
| 
	LLVM | 
	TriCore | 
	CPP | 
	next_suggestion | 
	MPU | 30 | 
	[
  "if",
  "(",
  "Base",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  "O",
  "<<",
  "<STR_LIT>",
  "[%",
  "<STR_LIT>",
  "<<",
  "StringRef",
  "(",
  "getRegisterName",
  "(",
  "Base",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ")",
  ".",
  "lower",
  "(",
  ")",
  "<<",
  "'",
  "]",
  "'",
  ";"
] | 
	[
  "const",
  "MCOperand",
  "&",
  "Base",
  "=",
  "MI",
  "->",
  "getOperand",
  "(",
  "OpNum",
  ")",
  ";",
  "const",
  "MCOperand",
  "&",
  "Disp",
  "=",
  "MI",
  "->",
  "getOperand",
  "(",
  "OpNum",
  "+",
  "<NUM_LIT>",
  ")",
  ";"
] | 
| 
	LLVM | 
	X86 | 
	CPP | 
	next_suggestion | 
	CPU | 31 | 
	[
  "}"
] | 
	[
  "SDValue",
  "P",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "SIGN_EXTEND",
  ",",
  "dl",
  ",",
  "DstVT",
  ",",
  "Op0",
  ")",
  ";",
  "return",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "SINT_TO_FP",
  ",",
  "dl",
  ",",
  "N",
  "->",
  "getValueType",
  "(",
  "<NUM_LIT>",
  ")",
  ",",
  "P",
  ")",
  ";",
  "}",
  "if",
  "(",
  "Op0",
  ".",
  "getOpcode",
  "(",
  ")",
  "==",
  "ISD",
  "::",
  "LOAD",
  ")",
  "{",
  "LoadSDNode",
  "*",
  "Ld",
  "=",
  "cast",
  "<",
  "LoadSDNode",
  ">",
  "(",
  "Op0",
  ".",
  "getNode",
  "(",
  ")",
  ")",
  ";",
  "EVT",
  "VT",
  "=",
  "Ld",
  "->",
  "getValueType",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "if",
  "(",
  "!",
  "Ld",
  "->",
  "isVolatile",
  "(",
  ")",
  "&&",
  "!",
  "N",
  "->",
  "getValueType",
  "(",
  "<NUM_LIT>",
  ")",
  ".",
  "isVector",
  "(",
  ")",
  "&&",
  "ISD",
  "::",
  "isNON_EXTLoad",
  "(",
  "Op0",
  ".",
  "getNode",
  "(",
  ")",
  ")",
  "&&",
  "Op0",
  ".",
  "hasOneUse",
  "(",
  ")",
  "&&",
  "!",
  "XTLI",
  "->",
  "getSubtarget",
  "(",
  ")",
  "->",
  "is64Bit",
  "(",
  ")",
  "&&",
  "VT",
  "==",
  "MVT",
  "::",
  "i64",
  ")",
  "{",
  "SDValue",
  "FILDChain",
  "=",
  "XTLI",
  "->",
  "BuildFILD",
  "(",
  "SDValue",
  "(",
  "N",
  ",",
  "<NUM_LIT>",
  ")",
  ",",
  "Ld",
  "->",
  "getValueType",
  "(",
  "<NUM_LIT>",
  ")",
  ",",
  "Ld",
  "->",
  "getChain",
  "(",
  ")",
  ",",
  "Op0",
  ",",
  "DAG",
  ")",
  ";",
  "DAG",
  ".",
  "ReplaceAllUsesOfValueWith",
  "(",
  "Op0",
  ".",
  "getValue",
  "(",
  "<NUM_LIT>",
  ")",
  ",",
  "FILDChain",
  ".",
  "getValue",
  "(",
  "<NUM_LIT>",
  ")",
  ")",
  ";",
  "return",
  "FILDChain",
  ";",
  "}"
] | 
| 
	LLVM | 
	AArch64 | 
	CPP | 
	stmt_completion | 
	CPU | 32 | 
	[
  "getValue",
  "(",
  ")",
  ")",
  ";"
] | 
	[
  "void",
  "AArch64InstructionSelector",
  "::",
  "renderTruncImm",
  "(",
  "MachineInstrBuilder",
  "&",
  "MIB",
  ",",
  "const",
  "MachineInstr",
  "&",
  "MI",
  ",",
  "int",
  "OpIdx",
  ")",
  "const",
  "{",
  "const",
  "MachineRegisterInfo",
  "&",
  "MRI",
  "=",
  "MI",
  ".",
  "getParent",
  "(",
  ")",
  "->",
  "getParent",
  "(",
  ")",
  "->",
  "getRegInfo",
  "(",
  ")",
  ";",
  "assert",
  "(",
  "MI",
  ".",
  "getOpcode",
  "(",
  ")",
  "==",
  "TargetOpcode",
  "::",
  "G_CONSTANT",
  "&&",
  "OpIdx",
  "==",
  "-",
  "<NUM_LIT>",
  "&&",
  "<STR_LIT>",
  "Expected G_CONSTANT",
  "<STR_LIT>",
  ")",
  ";",
  "Optional",
  "<",
  "int64_t",
  ">",
  "CstVal",
  "=",
  "getConstantVRegSExtVal",
  "(",
  "MI",
  ".",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ".",
  "getReg",
  "(",
  ")",
  ",",
  "MRI",
  ")",
  ";",
  "assert",
  "(",
  "CstVal",
  "&&",
  "<STR_LIT>",
  "Expected constant value",
  "<STR_LIT>",
  ")",
  ";",
  "MIB",
  ".",
  "addImm",
  "(",
  "CstVal",
  "."
] | 
| 
	LLVM | 
	Hexagon | 
	CPP | 
	next_suggestion | 
	DSP | 33 | 
	[
  "return",
  "Changed",
  ";"
] | 
	[
  "MachineBasicBlock",
  "::",
  "iterator",
  "I",
  ",",
  "E",
  ",",
  "NextI",
  ";",
  "for",
  "(",
  "I",
  "=",
  "B",
  ".",
  "begin",
  "(",
  ")",
  ",",
  "E",
  "=",
  "B",
  ".",
  "end",
  "(",
  ")",
  ";",
  "I",
  "!=",
  "E",
  ";",
  "I",
  "=",
  "NextI",
  ")",
  "{",
  "NextI",
  "=",
  "std",
  "::",
  "next",
  "(",
  "I",
  ")",
  ";",
  "if",
  "(",
  "isCondset",
  "(",
  "*",
  "I",
  ")",
  ")",
  "Changed",
  "|=",
  "split",
  "(",
  "*",
  "I",
  ",",
  "UpdRegs",
  ")",
  ";",
  "}"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	stmt_completion | 
	DSP | 34 | 
	[
  ">",
  ",",
  "Enc_454a26",
  "{"
] | 
	[
  "def",
  "C2_andn",
  ":",
  "HInst",
  "<",
  "(",
  "outs",
  "PredRegs",
  ":",
  "$",
  "Pd4",
  ")",
  ",",
  "(",
  "ins",
  "PredRegs",
  ":",
  "$",
  "Pt4",
  ",",
  "PredRegs",
  ":",
  "$",
  "Ps4",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "tc_640086b5",
  ",",
  "TypeCR"
] | 
| 
	LLVM | 
	ARM | 
	TD | 
	next_suggestion | 
	CPU | 35 | 
	[
  "let",
  "unsignedFlag",
  "=",
  "(",
  "?",
  "(",
  "i32",
  "VTI",
  ".",
  "Unsigned",
  ")",
  ")",
  ";"
] | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "imm",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "VTI",
  "=",
  "VTI_",
  ";",
  "let",
  "immediateType",
  "=",
  "immType",
  ";"
] | 
| 
	LLVM | 
	ARM | 
	CPP | 
	next_suggestion | 
	CPU | 36 | 
	[
  "}"
] | 
	[
  "void",
  "ARMTargetLowering",
  "::",
  "addMVEVectorTypes",
  "(",
  "bool",
  "HasMVEFP",
  ")",
  "{",
  "const",
  "MVT",
  "IntTypes",
  "[",
  "]",
  "=",
  "{",
  "MVT",
  "::",
  "v16i8",
  ",",
  "MVT",
  "::",
  "v8i16",
  ",",
  "MVT",
  "::",
  "v4i32",
  "}",
  ";",
  "for",
  "(",
  "auto",
  "VT",
  ":",
  "IntTypes",
  ")",
  "{",
  "addRegisterClass",
  "(",
  "VT",
  ",",
  "&",
  "ARM",
  "::",
  "QPRRegClass",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "VECTOR_SHUFFLE",
  ",",
  "VT",
  ",",
  "Custom",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "INSERT_VECTOR_ELT",
  ",",
  "VT",
  ",",
  "Custom",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "EXTRACT_VECTOR_ELT",
  ",",
  "VT",
  ",",
  "Custom",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "BUILD_VECTOR",
  ",",
  "VT",
  ",",
  "Custom",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SHL",
  ",",
  "VT",
  ",",
  "Custom",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SRA",
  ",",
  "VT",
  ",",
  "Custom",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SRL",
  ",",
  "VT",
  ",",
  "Custom",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SMIN",
  ",",
  "VT",
  ",",
  "Legal",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SMAX",
  ",",
  "VT",
  ",",
  "Legal",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "UMIN",
  ",",
  "VT",
  ",",
  "Legal",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "UMAX",
  ",",
  "VT",
  ",",
  "Legal",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "ABS",
  ",",
  "VT",
  ",",
  "Legal",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "UDIV",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SDIV",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "UREM",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SREM",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "if",
  "(",
  "!",
  "HasMVEFP",
  ")",
  "{",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "SINT_TO_FP",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "UINT_TO_FP",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "FP_TO_SINT",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "setOperationAction",
  "(",
  "ISD",
  "::",
  "FP_TO_UINT",
  ",",
  "VT",
  ",",
  "Expand",
  ")",
  ";",
  "}"
] | 
| 
	LLVM | 
	AArch64 | 
	TD | 
	stmt_completion | 
	CPU | 37 | 
	[
  ":",
  "$",
  "Rm",
  ")",
  ")",
  ")",
  ")",
  "]",
  ">",
  ";"
] | 
	[
  "def",
  "v2i32",
  ":",
  "BaseSIMDThreeSameVector",
  "<",
  "<NUM_LIT>",
  ",",
  "U",
  ",",
  "<NUM_LIT>",
  ",",
  "opc",
  ",",
  "V64",
  ",",
  "asm",
  ",",
  "<STR_LIT>",
  ",",
  "[",
  "(",
  "set",
  "V64",
  ":",
  "$",
  "Rd",
  ",",
  "(",
  "v2i32",
  "(",
  "OpNode",
  "(",
  "v2i32",
  "V64",
  ":",
  "$",
  "Rn",
  ")",
  ",",
  "(",
  "v2i32",
  "V64"
] | 
| 
	LLVM | 
	ARM | 
	TD | 
	stmt_completion | 
	CPU | 38 | 
	[
  "v2i32",
  ",",
  "VectorIndex32",
  ">",
  "{"
] | 
	[
  "def",
  "VDUPLN32d",
  ":",
  "VDUPLND",
  "<",
  "{",
  "?",
  ",",
  "<NUM_LIT>",
  ",",
  "<NUM_LIT>",
  ",",
  "<NUM_LIT>",
  "}",
  ",",
  "<STR_LIT>",
  ",",
  "<STR_LIT>",
  ","
] | 
| 
	GCC | 
	gcn | 
	CPP | 
	stmt_completion | 
	GPU | 39 | 
	[
  "<STR_LIT>",
  ")",
  ";"
] | 
	[
  "exit",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "}",
  "DLSYM_FN",
  "(",
  "hsa_status_string",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_agent_get_info",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_init",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_iterate_agents",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_region_get_info",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_queue_create",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_agent_iterate_regions",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_executable_destroy",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_executable_create",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_executable_global_variable_define",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_executable_load_code_object",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_executable_freeze",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_signal_create",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_memory_allocate",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_memory_copy",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_memory_free",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_signal_destroy",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_executable_get_symbol",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_executable_symbol_get_info",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_signal_wait_acquire",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_signal_wait_relaxed",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_signal_store_relaxed",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_queue_destroy",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_code_object_deserialize",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_queue_load_write_index_relaxed",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_queue_store_write_index_relaxed",
  ")",
  "DLSYM_FN",
  "(",
  "hsa_shut_down",
  ")",
  "return",
  ";",
  "fail",
  ":",
  "fprintf",
  "(",
  "stderr",
  ",",
  "<STR_LIT>",
  "Failed to find HSA functions in ",
  "<STR_LIT>",
  "HSA_RUNTIME_LIB",
  "<STR_LIT>",
  "\\n"
] | 
| 
	GCC | 
	aarch64 | 
	CPP | 
	stmt_completion | 
	CPU | 40 | 
	[
  ")",
  ";"
] | 
	[
  "void",
  "aarch64_gen_atomic_cas",
  "(",
  "rtx",
  "rval",
  ",",
  "rtx",
  "mem",
  ",",
  "rtx",
  "expected",
  ",",
  "rtx",
  "desired",
  ",",
  "rtx",
  "model",
  ")",
  "{",
  "rtx",
  "(",
  "*",
  "gen",
  ")",
  "(",
  "rtx",
  ",",
  "rtx",
  ",",
  "rtx",
  ",",
  "rtx",
  ")",
  ";",
  "machine_mode",
  "mode",
  ";",
  "mode",
  "=",
  "GET_MODE",
  "(",
  "mem",
  ")",
  ";",
  "switch",
  "(",
  "mode",
  ")",
  "{",
  "case",
  "QImode",
  ":",
  "gen",
  "=",
  "gen_aarch64_atomic_casqi",
  ";",
  "break",
  ";",
  "case",
  "HImode",
  ":",
  "gen",
  "=",
  "gen_aarch64_atomic_cashi",
  ";",
  "break",
  ";",
  "case",
  "SImode",
  ":",
  "gen",
  "=",
  "gen_aarch64_atomic_cassi",
  ";",
  "break",
  ";",
  "case",
  "DImode",
  ":",
  "gen",
  "=",
  "gen_aarch64_atomic_casdi",
  ";",
  "break",
  ";",
  "default",
  ":",
  "gcc_unreachable",
  "(",
  ")",
  ";",
  "}",
  "emit_insn",
  "(",
  "gen_rtx_SET",
  "(",
  "rval",
  ",",
  "expected",
  ")",
  ")",
  ";",
  "emit_insn",
  "(",
  "gen",
  "(",
  "rval",
  ",",
  "mem",
  ",",
  "desired",
  ",",
  "model",
  ")",
  ")",
  ";",
  "aarch64_gen_compare_reg",
  "(",
  "EQ",
  ",",
  "rval",
  ",",
  "expected"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 41 | 
	[
  "let",
  "isTaken",
  "=",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  ";"
] | 
	[
  "let",
  "isBranch",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "isPredicatedNew",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofRelax1",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofRelax2",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofMax1",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Defs",
  "=",
  "[",
  "PC",
  "]",
  ";",
  "let",
  "InputType",
  "=",
  "<STR_LIT>",
  ";",
  "let",
  "BaseOpcode",
  "=",
  "<STR_LIT>",
  ";"
] | 
| 
	GCC | 
	epiphany | 
	MD | 
	stmt_completion | 
	MPU | 42 | 
	[
  "QI",
  "V2HI",
  "V4QI",
  "]",
  ")"
] | 
	[
  "(",
  "define_mode_iterator",
  "WMODE",
  "[",
  "SI",
  "SF",
  "HI",
  "QI",
  "V2HI",
  "V4QI",
  "]",
  ")",
  "(",
  "define_mode_iterator",
  "WMODE2",
  "[",
  "SI",
  "SF",
  "HI"
] | 
| 
	GCC | 
	aarch64 | 
	CPP | 
	stmt_completion | 
	CPU | 43 | 
	[
  "<STR_LIT>",
  "w",
  "<STR_LIT>",
  "(",
  "a",
  ")",
  ":",
  ")",
  ";"
] | 
	[
  "_",
  "_",
  "asm__",
  "(",
  "<STR_LIT>",
  "saddlv %d0,%1.4s",
  "<STR_LIT>",
  ":",
  "<STR_LIT>",
  "=w",
  "<STR_LIT>",
  "(",
  "result",
  ")",
  ":"
] | 
| 
	GCC | 
	m68k | 
	MD | 
	next_suggestion | 
	MPU | 44 | 
	[
  "if",
  "(",
  "REGNO",
  "(",
  "operands",
  "[",
  "<NUM_LIT>",
  "]",
  ")",
  "=",
  "=",
  "REGNO",
  "(",
  "operands",
  "[",
  "<NUM_LIT>",
  "]",
  ")",
  ")"
] | 
	[
  "<STR_LIT>",
  "{",
  "if",
  "(",
  "FP_REG_P",
  "(",
  "operands",
  "[",
  "<NUM_LIT>",
  "]",
  ")",
  "&",
  "&",
  "FP_REG_P",
  "(",
  "operands",
  "[",
  "<NUM_LIT>",
  "]",
  ")",
  ")",
  "{"
] | 
| 
	LLVM | 
	X86 | 
	CPP | 
	next_suggestion | 
	CPU | 45 | 
	[
  "if",
  "(",
  "VA",
  ".",
  "getLocReg",
  "(",
  ")",
  "==",
  "X86",
  "::",
  "FP0",
  "||",
  "VA",
  ".",
  "getLocReg",
  "(",
  ")",
  "==",
  "X86",
  "::",
  "FP1",
  ")",
  "return",
  "false",
  ";"
] | 
	[
  "CallingConv",
  "::",
  "ID",
  "CC",
  "=",
  "F",
  ".",
  "getCallingConv",
  "(",
  ")",
  ";",
  "if",
  "(",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "C",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "Fast",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "Tail",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "SwiftTail",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "X86_FastCall",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "X86_StdCall",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "X86_ThisCall",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "X86_64_SysV",
  "&&",
  "CC",
  "!=",
  "CallingConv",
  "::",
  "Win64",
  ")",
  "return",
  "false",
  ";",
  "if",
  "(",
  "!",
  "isUInt",
  "<",
  "<NUM_LIT>",
  ">",
  "(",
  "X86MFInfo",
  "->",
  "getBytesToPopOnReturn",
  "(",
  ")",
  ")",
  ")",
  "return",
  "false",
  ";",
  "if",
  "(",
  "(",
  "CC",
  "==",
  "CallingConv",
  "::",
  "Fast",
  "&&",
  "TM",
  ".",
  "Options",
  ".",
  "GuaranteedTailCallOpt",
  ")",
  "||",
  "CC",
  "==",
  "CallingConv",
  "::",
  "Tail",
  "||",
  "CC",
  "==",
  "CallingConv",
  "::",
  "SwiftTail",
  ")",
  "return",
  "false",
  ";",
  "if",
  "(",
  "F",
  ".",
  "isVarArg",
  "(",
  ")",
  ")",
  "return",
  "false",
  ";",
  "SmallVector",
  "<",
  "unsigned",
  ",",
  "<NUM_LIT>",
  ">",
  "RetRegs",
  ";",
  "if",
  "(",
  "Ret",
  "->",
  "getNumOperands",
  "(",
  ")",
  ">",
  "<NUM_LIT>",
  ")",
  "{",
  "SmallVector",
  "<",
  "ISD",
  "::",
  "OutputArg",
  ",",
  "<NUM_LIT>",
  ">",
  "Outs",
  ";",
  "GetReturnInfo",
  "(",
  "CC",
  ",",
  "F",
  ".",
  "getReturnType",
  "(",
  ")",
  ",",
  "F",
  ".",
  "getAttributes",
  "(",
  ")",
  ",",
  "Outs",
  ",",
  "TLI",
  ",",
  "DL",
  ")",
  ";",
  "SmallVector",
  "<",
  "CCValAssign",
  ",",
  "<NUM_LIT>",
  ">",
  "ValLocs",
  ";",
  "CCState",
  "CCInfo",
  "(",
  "CC",
  ",",
  "F",
  ".",
  "isVarArg",
  "(",
  ")",
  ",",
  "*",
  "FuncInfo",
  ".",
  "MF",
  ",",
  "ValLocs",
  ",",
  "I",
  "->",
  "getContext",
  "(",
  ")",
  ")",
  ";",
  "CCInfo",
  ".",
  "AnalyzeReturn",
  "(",
  "Outs",
  ",",
  "RetCC_X86",
  ")",
  ";",
  "const",
  "Value",
  "*",
  "RV",
  "=",
  "Ret",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "Register",
  "Reg",
  "=",
  "getRegForValue",
  "(",
  "RV",
  ")",
  ";",
  "if",
  "(",
  "Reg",
  "==",
  "<NUM_LIT>",
  ")",
  "return",
  "false",
  ";",
  "if",
  "(",
  "ValLocs",
  ".",
  "size",
  "(",
  ")",
  "!=",
  "<NUM_LIT>",
  ")",
  "return",
  "false",
  ";",
  "CCValAssign",
  "&",
  "VA",
  "=",
  "ValLocs",
  "[",
  "<NUM_LIT>",
  "]",
  ";",
  "if",
  "(",
  "VA",
  ".",
  "getLocInfo",
  "(",
  ")",
  "!=",
  "CCValAssign",
  "::",
  "Full",
  ")",
  "return",
  "false",
  ";",
  "if",
  "(",
  "!",
  "VA",
  ".",
  "isRegLoc",
  "(",
  ")",
  ")",
  "return",
  "false",
  ";"
] | 
| 
	LLVM | 
	PowerPC | 
	CPP | 
	stmt_completion | 
	CPU | 46 | 
	[
  "NewCallSeqStart",
  ";"
] | 
	[
  "ISD",
  "::",
  "ArgFlagsTy",
  "ArgFlags",
  "=",
  "Outs",
  "[",
  "i",
  "]",
  ".",
  "Flags",
  ";",
  "bool",
  "Result",
  ";",
  "if",
  "(",
  "Outs",
  "[",
  "i",
  "]",
  ".",
  "IsFixed",
  ")",
  "{",
  "Result",
  "=",
  "CC_PPC32_SVR4",
  "(",
  "i",
  ",",
  "ArgVT",
  ",",
  "ArgVT",
  ",",
  "CCValAssign",
  "::",
  "Full",
  ",",
  "ArgFlags",
  ",",
  "CCInfo",
  ")",
  ";",
  "}",
  "else",
  "{",
  "Result",
  "=",
  "CC_PPC32_SVR4_VarArg",
  "(",
  "i",
  ",",
  "ArgVT",
  ",",
  "ArgVT",
  ",",
  "CCValAssign",
  "::",
  "Full",
  ",",
  "ArgFlags",
  ",",
  "CCInfo",
  ")",
  ";",
  "}",
  "if",
  "(",
  "Result",
  ")",
  "{",
  "errs",
  "(",
  ")",
  "<<",
  "<STR_LIT>",
  "Call operand #",
  "<STR_LIT>",
  "<<",
  "i",
  "<<",
  "<STR_LIT>",
  " has unhandled type ",
  "<STR_LIT>",
  "<<",
  "EVT",
  "(",
  "ArgVT",
  ")",
  ".",
  "getEVTString",
  "(",
  ")",
  "<<",
  "<STR_LIT>",
  "\\n",
  "<STR_LIT>",
  ";",
  "llvm_unreachable",
  "(",
  "<NUM_LIT>",
  ")",
  ";",
  "}",
  "}",
  "}",
  "else",
  "{",
  "CCInfo",
  ".",
  "AnalyzeCallOperands",
  "(",
  "Outs",
  ",",
  "CC_PPC32_SVR4",
  ")",
  ";",
  "}",
  "SmallVector",
  "<",
  "CCValAssign",
  ",",
  "<NUM_LIT>",
  ">",
  "ByValArgLocs",
  ";",
  "CCState",
  "CCByValInfo",
  "(",
  "CallConv",
  ",",
  "isVarArg",
  ",",
  "DAG",
  ".",
  "getMachineFunction",
  "(",
  ")",
  ",",
  "getTargetMachine",
  "(",
  ")",
  ",",
  "ByValArgLocs",
  ",",
  "*",
  "DAG",
  ".",
  "getContext",
  "(",
  ")",
  ")",
  ";",
  "CCByValInfo",
  ".",
  "AllocateStack",
  "(",
  "CCInfo",
  ".",
  "getNextStackOffset",
  "(",
  ")",
  ",",
  "PtrByteSize",
  ")",
  ";",
  "CCByValInfo",
  ".",
  "AnalyzeCallOperands",
  "(",
  "Outs",
  ",",
  "CC_PPC32_SVR4_ByVal",
  ")",
  ";",
  "unsigned",
  "NumBytes",
  "=",
  "CCByValInfo",
  ".",
  "getNextStackOffset",
  "(",
  ")",
  ";",
  "int",
  "SPDiff",
  "=",
  "CalculateTailCallSPDiff",
  "(",
  "DAG",
  ",",
  "isTailCall",
  ",",
  "NumBytes",
  ")",
  ";",
  "Chain",
  "=",
  "DAG",
  ".",
  "getCALLSEQ_START",
  "(",
  "Chain",
  ",",
  "DAG",
  ".",
  "getIntPtrConstant",
  "(",
  "NumBytes",
  ",",
  "true",
  ")",
  ")",
  ";",
  "SDValue",
  "CallSeqStart",
  "=",
  "Chain",
  ";",
  "SDValue",
  "LROp",
  ",",
  "FPOp",
  ";",
  "Chain",
  "=",
  "EmitTailCallLoadFPAndRetAddr",
  "(",
  "DAG",
  ",",
  "SPDiff",
  ",",
  "Chain",
  ",",
  "LROp",
  ",",
  "FPOp",
  ",",
  "false",
  ",",
  "dl",
  ")",
  ";",
  "SDValue",
  "StackPtr",
  "=",
  "DAG",
  ".",
  "getRegister",
  "(",
  "PPC",
  "::",
  "R1",
  ",",
  "MVT",
  "::",
  "i32",
  ")",
  ";",
  "SmallVector",
  "<",
  "std",
  "::",
  "pair",
  "<",
  "unsigned",
  ",",
  "SDValue",
  ">",
  ",",
  "<NUM_LIT>",
  ">",
  "RegsToPass",
  ";",
  "SmallVector",
  "<",
  "TailCallArgumentInfo",
  ",",
  "<NUM_LIT>",
  ">",
  "TailCallArguments",
  ";",
  "SmallVector",
  "<",
  "SDValue",
  ",",
  "<NUM_LIT>",
  ">",
  "MemOpChains",
  ";",
  "bool",
  "seenFloatArg",
  "=",
  "false",
  ";",
  "for",
  "(",
  "unsigned",
  "i",
  "=",
  "<NUM_LIT>",
  ",",
  "j",
  "=",
  "<NUM_LIT>",
  ",",
  "e",
  "=",
  "ArgLocs",
  ".",
  "size",
  "(",
  ")",
  ";",
  "i",
  "!=",
  "e",
  ";",
  "++",
  "i",
  ")",
  "{",
  "CCValAssign",
  "&",
  "VA",
  "=",
  "ArgLocs",
  "[",
  "i",
  "]",
  ";",
  "SDValue",
  "Arg",
  "=",
  "OutVals",
  "[",
  "i",
  "]",
  ";",
  "ISD",
  "::",
  "ArgFlagsTy",
  "Flags",
  "=",
  "Outs",
  "[",
  "i",
  "]",
  ".",
  "Flags",
  ";",
  "if",
  "(",
  "Flags",
  ".",
  "isByVal",
  "(",
  ")",
  ")",
  "{",
  "assert",
  "(",
  "(",
  "j",
  "<",
  "ByValArgLocs",
  ".",
  "size",
  "(",
  ")",
  ")",
  "&&",
  "<STR_LIT>",
  "Index out of bounds!",
  "<STR_LIT>",
  ")",
  ";",
  "CCValAssign",
  "&",
  "ByValVA",
  "=",
  "ByValArgLocs",
  "[",
  "j",
  "++",
  "]",
  ";",
  "assert",
  "(",
  "(",
  "VA",
  ".",
  "getValNo",
  "(",
  ")",
  "==",
  "ByValVA",
  ".",
  "getValNo",
  "(",
  ")",
  ")",
  "&&",
  "<STR_LIT>",
  "ValNo mismatch!",
  "<STR_LIT>",
  ")",
  ";",
  "unsigned",
  "LocMemOffset",
  "=",
  "ByValVA",
  ".",
  "getLocMemOffset",
  "(",
  ")",
  ";",
  "SDValue",
  "PtrOff",
  "=",
  "DAG",
  ".",
  "getIntPtrConstant",
  "(",
  "LocMemOffset",
  ")",
  ";",
  "PtrOff",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "ADD",
  ",",
  "dl",
  ",",
  "getPointerTy",
  "(",
  ")",
  ",",
  "StackPtr",
  ",",
  "PtrOff",
  ")",
  ";",
  "SDValue",
  "MemcpyCall",
  "=",
  "CreateCopyOfByValArgument",
  "(",
  "Arg",
  ",",
  "PtrOff",
  ",",
  "CallSeqStart",
  ".",
  "getNode",
  "(",
  ")",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ",",
  "Flags",
  ",",
  "DAG",
  ",",
  "dl",
  ")",
  ";",
  "SDValue",
  "NewCallSeqStart",
  "=",
  "DAG",
  ".",
  "getCALLSEQ_START",
  "(",
  "MemcpyCall",
  ",",
  "CallSeqStart",
  ".",
  "getNode",
  "(",
  ")",
  "->",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ")",
  ";",
  "DAG",
  ".",
  "ReplaceAllUsesWith",
  "(",
  "CallSeqStart",
  ".",
  "getNode",
  "(",
  ")",
  ",",
  "NewCallSeqStart",
  ".",
  "getNode",
  "(",
  ")",
  ")",
  ";",
  "Chain",
  "=",
  "CallSeqStart",
  "="
] | 
| 
	LLVM | 
	ARM | 
	CPP | 
	next_suggestion | 
	CPU | 47 | 
	[
  "}"
] | 
	[
  "void",
  "addProcIFlagsOperands",
  "(",
  "MCInst",
  "&",
  "Inst",
  ",",
  "unsigned",
  "N",
  ")",
  "const",
  "{",
  "assert",
  "(",
  "N",
  "==",
  "<NUM_LIT>",
  "&&",
  "<STR_LIT>",
  "Invalid number of operands!",
  "<STR_LIT>",
  ")",
  ";",
  "Inst",
  ".",
  "addOperand",
  "(",
  "MCOperand",
  "::",
  "createImm",
  "(",
  "unsigned",
  "(",
  "getProcIFlags",
  "(",
  ")",
  ")",
  ")",
  ")",
  ";"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	stmt_completion | 
	DSP | 48 | 
	[
  "<NUM_LIT>",
  ";"
] | 
	[
  "def",
  "A2_addsp",
  ":",
  "HInst",
  "<",
  "(",
  "outs",
  "DoubleRegs",
  ":",
  "$",
  "Rdd32",
  ")",
  ",",
  "(",
  "ins",
  "IntRegs",
  ":",
  "$",
  "Rs32",
  ",",
  "DoubleRegs",
  ":",
  "$",
  "Rtt32",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "tc_679309b8",
  ",",
  "TypeALU64",
  ">",
  "{",
  "let",
  "isPseudo",
  "="
] | 
| 
	GCC | 
	mips | 
	MD | 
	next_suggestion | 
	CPU | 49 | 
	[
  "<STR_LIT>"
] | 
	[
  "(",
  "define_insn",
  "<STR_LIT>",
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "V2HI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "unspec",
  ":",
  "V2HI",
  "[",
  "(",
  "match_operand",
  ":",
  "V4QI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "]",
  "UNSPEC_PRECEU_PH_QBLA",
  ")",
  ")",
  "]"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 50 | 
	[
  "let",
  "opExtentAlign",
  "=",
  "<NUM_LIT>",
  ";"
] | 
	[
  "def",
  "C2_muxii",
  ":",
  "HInst",
  "<",
  "(",
  "outs",
  "IntRegs",
  ":",
  "$",
  "Rd32",
  ")",
  ",",
  "(",
  "ins",
  "PredRegs",
  ":",
  "$",
  "Pu4",
  ",",
  "s32_0Imm",
  ":",
  "$",
  "Ii",
  ",",
  "s8_0Imm",
  ":",
  "$",
  "II",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "tc_4c5ba658",
  ",",
  "TypeALU32_2op",
  ">",
  ",",
  "Enc_830e5d",
  "{",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "hasNewValue",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "opNewValue",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "isExtendable",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "opExtendable",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "isExtentSigned",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "opExtentBits",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	GCC | 
	rs6000 | 
	MD | 
	stmt_completion | 
	CPU | 51 | 
	[
  ")"
] | 
	[
  "(",
  "define_predicate",
  "<STR_LIT>",
  "(",
  "and",
  "(",
  "match_operand",
  "<NUM_LIT>",
  "<STR_LIT>"
] | 
| 
	LLVM | 
	ARM | 
	TD | 
	next_suggestion | 
	CPU | 52 | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Rm",
  ";"
] | 
	[
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Rm",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	LLVM | 
	GBZ80 | 
	TD | 
	next_suggestion | 
	MPU | 53 | 
	[
  "field",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Inst",
  ";"
] | 
	[
  "class",
  "GBZ80Inst",
  "<",
  "dag",
  "outs",
  ",",
  "dag",
  "ins",
  ",",
  "string",
  "asmstr",
  ">",
  ":",
  "Instruction",
  "{",
  "let",
  "Namespace",
  "=",
  "<STR_LIT>",
  ";"
] | 
| 
	GCC | 
	aarch64 | 
	CPP | 
	stmt_completion | 
	CPU | 54 | 
	[
  ",",
  "_",
  "_",
  "c",
  ")",
  ";"
] | 
	[
  "return",
  "_",
  "_",
  "builtin_aarch64_simd_bslv16qi_uuuu",
  "(",
  "_",
  "_",
  "a",
  ",",
  "_",
  "_",
  "b"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	stmt_completion | 
	DSP | 55 | 
	[
  "=",
  "<NUM_LIT>",
  ";"
] | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofRelax1",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofRelax2",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Defs",
  "=",
  "[",
  "LC1",
  ",",
  "SA1",
  "]",
  ";",
  "let",
  "isExtendable",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "opExtendable",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "isExtentSigned",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "opExtentBits"
] | 
| 
	LLVM | 
	Mips | 
	CPP | 
	program_repair | 
	CPU | 56 | 
	[
  "<FIXS>",
  "const",
  "GlobalValue",
  "*",
  "Val",
  "=",
  "G",
  "->",
  "getGlobal",
  "(",
  ")",
  ";",
  "InternalLinkage",
  "=",
  "Val",
  "->",
  "hasInternalLinkage",
  "(",
  ")",
  ";",
  "<FIXE>",
  "<FIXS>",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "Chain",
  ",",
  "FuncInfo",
  "->",
  "callPtrInfo",
  "(",
  "Val",
  ")",
  ")",
  ";",
  "<FIXE>",
  "<FIXS>",
  "Callee",
  "=",
  "getAddrGlobal",
  "(",
  "G",
  ",",
  "Ty",
  ",",
  "DAG",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "Chain",
  ",",
  "FuncInfo",
  "->",
  "callPtrInfo",
  "(",
  "Val",
  ")",
  ")",
  ";",
  "<FIXE>",
  "<FIXS>",
  "Callee",
  "=",
  "DAG",
  ".",
  "getTargetExternalSymbol",
  "(",
  "Sym",
  ",",
  "getPointerTy",
  "(",
  ")",
  ",",
  "<FIXE>",
  "<FIXS>",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "Chain",
  ",",
  "FuncInfo",
  "->",
  "callPtrInfo",
  "(",
  "Sym",
  ")",
  ")",
  ";",
  "<FIXE>",
  "<FIXS>",
  "Callee",
  "=",
  "getAddrGlobal",
  "(",
  "S",
  ",",
  "Ty",
  ",",
  "DAG",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "Chain",
  ",",
  "FuncInfo",
  "->",
  "callPtrInfo",
  "(",
  "Sym",
  ")",
  ")",
  ";",
  "<FIXE>"
] | 
	[
  "if",
  "(",
  "GlobalAddressSDNode",
  "*",
  "G",
  "=",
  "dyn_cast",
  "GlobalAddressSDNode",
  ">",
  "(",
  "Callee",
  ")",
  ")",
  "{",
  "if",
  "(",
  "IsPICCall",
  ")",
  "{",
  "<BUGS>",
  "InternalLinkage",
  "=",
  "G",
  "->",
  "getGlobal",
  "(",
  ")",
  "->",
  "hasInternalLinkage",
  "(",
  ")",
  ";",
  "<BUGE>",
  "if",
  "(",
  "InternalLinkage",
  ")",
  "Callee",
  "=",
  "getAddrLocal",
  "(",
  "G",
  ",",
  "Ty",
  ",",
  "DAG",
  ",",
  "HasMips64",
  ")",
  ";",
  "else",
  "if",
  "(",
  "LargeGOT",
  ")",
  "Callee",
  "=",
  "getAddrGlobalLargeGOT",
  "(",
  "G",
  ",",
  "Ty",
  ",",
  "DAG",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<BUGS>",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ")",
  ";",
  "<BUGE>",
  "else",
  "<BUGS>",
  "Callee",
  "=",
  "getAddrGlobal",
  "(",
  "G",
  ",",
  "Ty",
  ",",
  "DAG",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ")",
  ";",
  "<BUGE>",
  "}",
  "elseCallee",
  "=",
  "DAG",
  ".",
  "getTargetGlobalAddress",
  "(",
  "G",
  "->",
  "getGlobal",
  "(",
  ")",
  ",",
  "DL",
  ",",
  "getPointerTy",
  "(",
  ")",
  ",",
  "<NUM_LIT>",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ")",
  ";",
  "GlobalOrExternal",
  "=",
  "true",
  ";",
  "}",
  "else",
  "if",
  "(",
  "ExternalSymbolSDNode",
  "*",
  "S",
  "=",
  "dyn_cast",
  "ExternalSymbolSDNode",
  ">",
  "(",
  "Callee",
  ")",
  ")",
  "{",
  "if",
  "(",
  "!",
  "IsN64",
  "&&",
  "!",
  "IsPIC",
  ")",
  "<BUGS>",
  "Callee",
  "=",
  "DAG",
  ".",
  "getTargetExternalSymbol",
  "(",
  "S",
  "->",
  "getSymbol",
  "(",
  ")",
  ",",
  "getPointerTy",
  "(",
  ")",
  ",",
  "<BUGE>",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ")",
  ";",
  "else",
  "if",
  "(",
  "LargeGOT",
  ")",
  "Callee",
  "=",
  "getAddrGlobalLargeGOT",
  "(",
  "S",
  ",",
  "Ty",
  ",",
  "DAG",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "<BUGS>",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ")",
  ";",
  "<BUGE>",
  "else",
  "<BUGS>",
  "Callee",
  "=",
  "getAddrGlobal",
  "(",
  "S",
  ",",
  "Ty",
  ",",
  "DAG",
  ",",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ")",
  ";",
  "<BUGE>",
  "GlobalOrExternal",
  "=",
  "true",
  ";",
  "}"
] | 
| 
	GCC | 
	alpha | 
	MD | 
	stmt_completion | 
	MPU | 57 | 
	[
  ")",
  "]"
] | 
	[
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "DI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "unspec_volatile",
  ":",
  "DI",
  "[",
  "(",
  "const_int",
  "<NUM_LIT>",
  ")",
  "]",
  "UNSPECV_SC",
  ")",
  ")",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "I48MODE",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "match_operand",
  ":",
  "I48MODE",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")"
] | 
| 
	GCC | 
	i386 | 
	MD | 
	stmt_completion | 
	CPU | 58 | 
	[
  ")"
] | 
	[
  "(",
  "define_reservation",
  "<STR_LIT>",
  "<STR_LIT>"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 59 | 
	[
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Rs32",
  ";"
] | 
	[
  "class",
  "Enc_a1e29d",
  ":",
  "OpcodeHexagon",
  "{",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Ii",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Ii",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "II",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "II",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "II",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";"
] | 
| 
	GCC | 
	csky | 
	CPP | 
	code_generation | 
	CPU | 60 | 
	[
  "static",
  "void",
  "push_csky_minipool_fix",
  "(",
  "rtx_insn",
  "*",
  "insn",
  ",",
  "HOST_WIDE_INT",
  "address",
  ",",
  "rtx",
  "*",
  "loc",
  ",",
  "machine_mode",
  "mode",
  ",",
  "rtx",
  "value",
  ")",
  "{",
  ":",
  "CSKY_LRW16_RANGE",
  ")",
  "(",
  "GET_MODE_SIZE",
  "(",
  "(",
  "mode",
  ")",
  ")",
  ">=",
  "<NUM_LIT>",
  "?",
  "GET_MODE_SIZE",
  "(",
  "(",
  "mode",
  ")",
  ")",
  ":",
  "<NUM_LIT>",
  ")",
  "Mfix",
  "*",
  "fix",
  "=",
  "(",
  "Mfix",
  "*",
  ")",
  "obstack_alloc",
  "(",
  "&",
  "minipool_obstack",
  ",",
  "sizeof",
  "(",
  "*",
  "fix",
  ")",
  ")",
  ";",
  "fix",
  "->",
  "insn",
  "=",
  "insn",
  ";",
  "fix",
  "->",
  "address",
  "=",
  "address",
  ";",
  "fix",
  "->",
  "loc",
  "=",
  "loc",
  ";",
  "fix",
  "->",
  "mode",
  "=",
  "mode",
  ";",
  "fix",
  "->",
  "fix_size",
  "=",
  "CSKY_MINIPOOL_FIX_SIZE",
  "(",
  "mode",
  ")",
  ";",
  "fix",
  "->",
  "value",
  "=",
  "value",
  ";",
  "fix",
  "->",
  "forwards",
  "=",
  "CSKY_CONSTANT_POOL_RANGE",
  ";",
  "fix",
  "->",
  "backwards",
  "=",
  "<NUM_LIT>",
  ";",
  "fix",
  "->",
  "minipool",
  "=",
  "NULL",
  ";",
  "gcc_assert",
  "(",
  "fix",
  "->",
  "forwards",
  "||",
  "fix",
  "->",
  "backwards",
  ")",
  ";",
  "if",
  "(",
  "dump_file",
  ")",
  "{",
  "fprintf",
  "(",
  "dump_file",
  ",",
  "<STR_LIT>",
  ";; %smode fixup for i%d; addr %lu, range (%ld,%ld): ",
  "<STR_LIT>",
  ",",
  "GET_MODE_NAME",
  "(",
  "mode",
  ")",
  ",",
  "INSN_UID",
  "(",
  "insn",
  ")",
  ",",
  "(",
  "unsigned",
  "long",
  ")",
  "address",
  ",",
  "-",
  "<NUM_LIT>",
  "*",
  "(",
  "long",
  ")",
  "fix",
  "->",
  "backwards",
  ",",
  "(",
  "long",
  ")",
  "fix",
  "->",
  "forwards",
  ")",
  ";",
  "print_csky_value",
  "(",
  "dump_file",
  ",",
  "fix",
  "->",
  "value",
  ")",
  ";",
  "fprintf",
  "(",
  "dump_file",
  ",",
  "<STR_LIT>",
  "\\n",
  "<STR_LIT>",
  ")",
  ";",
  "}",
  "fix",
  "->",
  "next",
  "=",
  "NULL",
  ";",
  "if",
  "(",
  "minipool_fix_head",
  "!=",
  "NULL",
  ")",
  "minipool_fix_tail",
  "->",
  "next",
  "=",
  "fix",
  ";",
  "else",
  "minipool_fix_head",
  "=",
  "fix",
  ";",
  "minipool_fix_tail",
  "=",
  "fix",
  ";",
  "}"
] | 
	[
  "Record",
  "INSN",
  ",",
  "which",
  "will",
  "need",
  "fixing",
  "up",
  "to",
  "load",
  "a",
  "value",
  "from",
  "the",
  "minipool",
  ".",
  "ADDRESS",
  "is",
  "the",
  "offset",
  "of",
  "the",
  "insn",
  "since",
  "the",
  "start",
  "of",
  "the",
  "function",
  ";",
  "LOC",
  "is",
  "a",
  "pointer",
  "to",
  "the",
  "part",
  "of",
  "the",
  "insn",
  "which",
  "requires",
  "fixing",
  ";",
  "VALUE",
  "is",
  "the",
  "constant",
  "that",
  "must",
  "be",
  "loaded",
  ",",
  "which",
  "is",
  "of",
  "type",
  "MODE",
  "."
] | 
| 
	LLVM | 
	Hexagon | 
	CPP | 
	next_suggestion | 
	DSP | 61 | 
	[
  "return",
  "PReg1",
  "==",
  "PReg2",
  "&&",
  "Hexagon",
  "::",
  "PredRegsRegClass",
  ".",
  "contains",
  "(",
  "PReg1",
  ")",
  "&&",
  "Hexagon",
  "::",
  "PredRegsRegClass",
  ".",
  "contains",
  "(",
  "PReg2",
  ")",
  "&&",
  "getPredicateSense",
  "(",
  "MI1",
  ",",
  "HII",
  ")",
  "!=",
  "getPredicateSense",
  "(",
  "MI2",
  ",",
  "HII",
  ")",
  "&&",
  "HII",
  "->",
  "isDotNewInst",
  "(",
  "MI1",
  ")",
  "==",
  "HII",
  "->",
  "isDotNewInst",
  "(",
  "MI2",
  ")",
  ";"
] | 
	[
  "bool",
  "HexagonPacketizerList",
  "::",
  "arePredicatesComplements",
  "(",
  "MachineInstr",
  "*",
  "MI1",
  ",",
  "MachineInstr",
  "*",
  "MI2",
  ")",
  "{",
  "if",
  "(",
  "getPredicateSense",
  "(",
  "MI1",
  ",",
  "HII",
  ")",
  "==",
  "PK_Unknown",
  "||",
  "getPredicateSense",
  "(",
  "MI2",
  ",",
  "HII",
  ")",
  "==",
  "PK_Unknown",
  ")",
  "return",
  "false",
  ";",
  "SUnit",
  "*",
  "SU",
  "=",
  "MIToSUnit",
  "[",
  "MI1",
  "]",
  ";",
  "for",
  "(",
  "auto",
  "I",
  ":",
  "CurrentPacketMIs",
  ")",
  "{",
  "SUnit",
  "*",
  "PacketSU",
  "=",
  "MIToSUnit",
  ".",
  "find",
  "(",
  "I",
  ")",
  "->",
  "second",
  ";",
  "if",
  "(",
  "PacketSU",
  "->",
  "isSucc",
  "(",
  "SU",
  ")",
  ")",
  "{",
  "for",
  "(",
  "unsigned",
  "i",
  "=",
  "<NUM_LIT>",
  ";",
  "i",
  "<",
  "PacketSU",
  "->",
  "Succs",
  ".",
  "size",
  "(",
  ")",
  ";",
  "++",
  "i",
  ")",
  "{",
  "auto",
  "Dep",
  "=",
  "PacketSU",
  "->",
  "Succs",
  "[",
  "i",
  "]",
  ";",
  "if",
  "(",
  "Dep",
  ".",
  "getSUnit",
  "(",
  ")",
  "==",
  "SU",
  "&&",
  "Dep",
  ".",
  "getKind",
  "(",
  ")",
  "==",
  "SDep",
  "::",
  "Data",
  "&&",
  "Hexagon",
  "::",
  "PredRegsRegClass",
  ".",
  "contains",
  "(",
  "Dep",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ")",
  "{",
  "if",
  "(",
  "restrictingDepExistInPacket",
  "(",
  "I",
  ",",
  "Dep",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ")",
  "return",
  "false",
  ";",
  "}",
  "}",
  "}",
  "}",
  "unsigned",
  "PReg1",
  "=",
  "getPredicatedRegister",
  "(",
  "MI1",
  ",",
  "HII",
  ")",
  ";",
  "unsigned",
  "PReg2",
  "=",
  "getPredicatedRegister",
  "(",
  "MI2",
  ",",
  "HII",
  ")",
  ";"
] | 
| 
	LLVM | 
	X86 | 
	TD | 
	program_repair | 
	CPU | 62 | 
	[
  "<FIXS>",
  "def",
  "_Fp32",
  ":",
  "FpIf32",
  "(",
  "outs",
  "RFP32",
  ":",
  "$",
  "dst",
  ")",
  ",",
  "(",
  "ins",
  "RFP32",
  ":",
  "$",
  "src1",
  ",",
  "RFP32",
  ":",
  "$",
  "src2",
  ")",
  ",",
  "CondMovFP",
  ",",
  "<FIXE>",
  "<FIXS>",
  "def",
  "_Fp64",
  ":",
  "FpIf64",
  "(",
  "outs",
  "RFP64",
  ":",
  "$",
  "dst",
  ")",
  ",",
  "(",
  "ins",
  "RFP64",
  ":",
  "$",
  "src1",
  ",",
  "RFP64",
  ":",
  "$",
  "src2",
  ")",
  ",",
  "CondMovFP",
  ",",
  "<FIXE>"
] | 
	[
  "multiclass",
  "FPCMov",
  "PatLeaf",
  "cc",
  ">",
  "{",
  "<BUGS>",
  "def",
  "_Fp32",
  ":",
  "FpI",
  "(",
  "outs",
  "RFP32",
  ":",
  "$",
  "dst",
  ")",
  ",",
  "(",
  "ins",
  "RFP32",
  ":",
  "$",
  "src1",
  ",",
  "RFP32",
  ":",
  "$",
  "src2",
  ")",
  ",",
  "CondMovFP",
  ",",
  "<BUGE>",
  "[",
  "(",
  "set",
  "RFP32",
  ":",
  "$",
  "dst",
  ",",
  "(",
  "X86cmov",
  "RFP32",
  ":",
  "$",
  "src1",
  ",",
  "RFP32",
  ":",
  "$",
  "src2",
  ",",
  "cc",
  ")",
  ")",
  "]",
  ">",
  ";",
  "<BUGS>",
  "def",
  "_Fp64",
  ":",
  "FpI",
  "(",
  "outs",
  "RFP64",
  ":",
  "$",
  "dst",
  ")",
  ",",
  "(",
  "ins",
  "RFP64",
  ":",
  "$",
  "src1",
  ",",
  "RFP64",
  ":",
  "$",
  "src2",
  ")",
  ",",
  "CondMovFP",
  ",",
  "<BUGE>",
  "[",
  "(",
  "set",
  "RFP64",
  ":",
  "$",
  "dst",
  ",",
  "(",
  "X86cmov",
  "RFP64",
  ":",
  "$",
  "src1",
  ",",
  "RFP64",
  ":",
  "$",
  "src2",
  ",",
  "cc",
  ")",
  ")",
  "]",
  ">",
  ";",
  "def",
  "_Fp80",
  ":",
  "FpI_",
  "(",
  "outs",
  "RFP80",
  ":",
  "$",
  "dst",
  ")",
  ",",
  "(",
  "ins",
  "RFP80",
  ":",
  "$",
  "src1",
  ",",
  "RFP80",
  ":",
  "$",
  "src2",
  ")",
  ",",
  "CondMovFP",
  ","
] | 
| 
	LLVM | 
	AArch64 | 
	TD | 
	stmt_completion | 
	CPU | 63 | 
	[
  ")",
  "(",
  "v2i32",
  "(",
  "INSERT_SUBREG",
  "(",
  "v2i32",
  "(",
  "IMPLICIT_DEF",
  ")",
  ")",
  ",",
  "FPR32Op",
  ":",
  "$",
  "Rd",
  ",",
  "ssub",
  ")",
  ")",
  ",",
  "V64",
  ":",
  "$",
  "Rn",
  ",",
  "V128",
  ":",
  "$",
  "Rm",
  ",",
  "VectorIndexS",
  ":",
  "$",
  "idx",
  ")",
  ")",
  ",",
  "ssub",
  ")",
  ">",
  ";"
] | 
	[
  "def",
  ":",
  "Pat",
  "<",
  "(",
  "i32",
  "(",
  "Accum",
  "(",
  "i32",
  "FPR32Op",
  ":",
  "$",
  "Rd",
  ")",
  ",",
  "(",
  "i32",
  "(",
  "vector_extract",
  "(",
  "v4i32",
  "(",
  "insert_subvector",
  "(",
  "undef",
  ")",
  ",",
  "(",
  "v2i32",
  "(",
  "int_aarch64_neon_sqrdmulh",
  "(",
  "v2i32",
  "V64",
  ":",
  "$",
  "Rn",
  ")",
  ",",
  "(",
  "v2i32",
  "(",
  "AArch64duplane32",
  "(",
  "v4i32",
  "V128",
  ":",
  "$",
  "Rm",
  ")",
  ",",
  "VectorIndexS",
  ":",
  "$",
  "idx",
  ")",
  ")",
  ")",
  ")",
  ",",
  "(",
  "i64",
  "<NUM_LIT>",
  ")",
  ")",
  ")",
  ",",
  "(",
  "i64",
  "<NUM_LIT>",
  ")",
  ")",
  ")",
  ")",
  ")",
  ",",
  "(",
  "EXTRACT_SUBREG",
  "(",
  "v2i32",
  "(",
  "!",
  "cast",
  "<",
  "Instruction",
  ">",
  "(",
  "NAME",
  "#",
  "v2i32_indexed"
] | 
| 
	LLVM | 
	ECLair | 
	CPP | 
	stmt_completion | 
	MPU | 64 | 
	[
  ")",
  ";"
] | 
	[
  "const",
  "MCExpr",
  "*",
  "Val",
  "=",
  "getImm",
  "(",
  ")",
  ";",
  "return",
  "static_cast",
  "<",
  "const",
  "MCConstantExpr",
  "*",
  ">",
  "(",
  "Val",
  ")",
  "->",
  "getValue",
  "("
] | 
| 
	LLVM | 
	Hexagon | 
	CPP | 
	next_suggestion | 
	DSP | 65 | 
	[
  "LLVM_DEBUG",
  "(",
  "dbgs",
  "(",
  ")",
  "<<",
  "<STR_LIT>",
  " Add instruction ",
  "<STR_LIT>",
  "<<",
  "*",
  "MI",
  ")",
  ";"
] | 
	[
  "if",
  "(",
  "!",
  "MI",
  ")",
  "return",
  ";",
  "for",
  "(",
  "const",
  "MachineOperand",
  "&",
  "MO",
  ":",
  "MI",
  "->",
  "operands",
  "(",
  ")",
  ")",
  "if",
  "(",
  "MO",
  ".",
  "isReg",
  "(",
  ")",
  "&&",
  "MO",
  ".",
  "isDef",
  "(",
  ")",
  "&&",
  "!",
  "MO",
  ".",
  "isImplicit",
  "(",
  ")",
  ")",
  "RegDefs",
  ".",
  "insert",
  "(",
  "MO",
  ".",
  "getReg",
  "(",
  ")",
  ")",
  ";",
  "if",
  "(",
  "TII",
  "->",
  "isZeroCost",
  "(",
  "MI",
  "->",
  "getOpcode",
  "(",
  ")",
  ")",
  ")",
  "return",
  ";",
  "if",
  "(",
  "!",
  "Resources",
  "->",
  "canReserveResources",
  "(",
  "*",
  "MI",
  ")",
  "||",
  "isNewStore",
  "(",
  "*",
  "MI",
  ")",
  ")",
  "{",
  "assert",
  "(",
  "TII",
  "->",
  "mayBeNewStore",
  "(",
  "*",
  "MI",
  ")",
  "&&",
  "<STR_LIT>",
  "Expecting .new store",
  "<STR_LIT>",
  ")",
  ";",
  "MachineFunction",
  "*",
  "MF",
  "=",
  "MI",
  "->",
  "getParent",
  "(",
  ")",
  "->",
  "getParent",
  "(",
  ")",
  ";",
  "MachineInstr",
  "*",
  "NewMI",
  "=",
  "MF",
  "->",
  "CreateMachineInstr",
  "(",
  "TII",
  "->",
  "get",
  "(",
  "TII",
  "->",
  "getDotNewOp",
  "(",
  "*",
  "MI",
  ")",
  ")",
  ",",
  "MI",
  "->",
  "getDebugLoc",
  "(",
  ")",
  ")",
  ";",
  "if",
  "(",
  "Resources",
  "->",
  "canReserveResources",
  "(",
  "*",
  "NewMI",
  ")",
  ")",
  "Resources",
  "->",
  "reserveResources",
  "(",
  "*",
  "NewMI",
  ")",
  ";",
  "else",
  "Resources",
  "->",
  "reserveResources",
  "(",
  "*",
  "MI",
  ")",
  ";",
  "MF",
  "->",
  "delete",
  "MachineInstr",
  "(",
  "NewMI",
  ")",
  ";",
  "}",
  "else",
  "Resources",
  "->",
  "reserveResources",
  "(",
  "*",
  "MI",
  ")",
  ";"
] | 
| 
	GCC | 
	bfin | 
	CPP | 
	stmt_completion | 
	DSP | 66 | 
	[
  "+",
  "<NUM_LIT>",
  ")",
  "return",
  "<NUM_LIT>",
  ";"
] | 
	[
  "if",
  "(",
  "group",
  "==",
  "<NUM_LIT>",
  ")",
  "{",
  "if",
  "(",
  "D_REGNO_P",
  "(",
  "regno",
  ")",
  ")",
  "{",
  "group",
  "=",
  "<NUM_LIT>",
  ";",
  "first_dreg_to_save",
  "=",
  "lastdreg",
  "=",
  "regno",
  "-",
  "REG_R0",
  ";",
  "}",
  "else",
  "if",
  "(",
  "regno",
  ">=",
  "REG_P0",
  "&&",
  "regno",
  "<=",
  "REG_P7",
  ")",
  "{",
  "group",
  "=",
  "<NUM_LIT>",
  ";",
  "first_preg_to_save",
  "=",
  "lastpreg",
  "=",
  "regno",
  "-",
  "REG_P0",
  ";",
  "}",
  "else",
  "return",
  "<NUM_LIT>",
  ";",
  "continue",
  ";",
  "}",
  "if",
  "(",
  "group",
  "==",
  "<NUM_LIT>",
  ")",
  "{",
  "if",
  "(",
  "regno",
  ">=",
  "REG_P0",
  "&&",
  "regno",
  "<=",
  "REG_P7",
  ")",
  "{",
  "group",
  "=",
  "<NUM_LIT>",
  ";",
  "first_preg_to_save",
  "=",
  "lastpreg",
  "=",
  "regno",
  "-",
  "REG_P0",
  ";",
  "}",
  "else",
  "if",
  "(",
  "regno",
  "!=",
  "REG_R0",
  "+",
  "lastdreg"
] | 
| 
	GCC | 
	xtensa | 
	CPP | 
	stmt_completion | 
	MPU | 67 | 
	[
  ";"
] | 
	[
  "x",
  "=",
  "XEXP",
  "(",
  "x",
  ",",
  "<NUM_LIT>",
  ")",
  ";",
  "return",
  "(",
  "SYMBOL_REF_P",
  "(",
  "x",
  ")",
  "||",
  "CONST_INT_P",
  "(",
  "x",
  ")",
  ")",
  "&&",
  "CONSTANT_POOL_ADDRESS_P",
  "(",
  "x",
  ")",
  ";",
  "}",
  "if",
  "(",
  "CONST_INT_P",
  "(",
  "x",
  ")",
  "&&",
  "!",
  "xtensa_simm12b",
  "(",
  "INTVAL",
  "(",
  "x",
  ")",
  ")",
  ")",
  "return",
  "true",
  ";",
  "return",
  "false"
] | 
| 
	LLVM | 
	X86 | 
	CPP | 
	next_suggestion | 
	CPU | 68 | 
	[
  "int",
  "FI",
  "=",
  "MFI",
  "->",
  "CreateFixedObject",
  "(",
  "ValVT",
  ".",
  "getSizeInBits",
  "(",
  ")",
  "/",
  "<NUM_LIT>",
  ",",
  "VA",
  ".",
  "getLocMemOffset",
  "(",
  ")",
  ",",
  "isImmutable",
  ")",
  ";"
] | 
	[
  "SDValue",
  "X86TargetLowering",
  "::",
  "LowerMemArgument",
  "(",
  "SDValue",
  "Chain",
  ",",
  "CallingConv",
  "::",
  "ID",
  "CallConv",
  ",",
  "const",
  "SmallVectorImpl",
  "<",
  "ISD",
  "::",
  "InputArg",
  ">",
  "&",
  "Ins",
  ",",
  "DebugLoc",
  "dl",
  ",",
  "SelectionDAG",
  "&",
  "DAG",
  ",",
  "const",
  "CCValAssign",
  "&",
  "VA",
  ",",
  "MachineFrameInfo",
  "*",
  "MFI",
  ",",
  "unsigned",
  "i",
  ")",
  "const",
  "{",
  "ISD",
  "::",
  "ArgFlagsTy",
  "Flags",
  "=",
  "Ins",
  "[",
  "i",
  "]",
  ".",
  "Flags",
  ";",
  "bool",
  "AlwaysUseMutable",
  "=",
  "FuncIsMadeTailCallSafe",
  "(",
  "CallConv",
  ")",
  ";",
  "bool",
  "isImmutable",
  "=",
  "!",
  "AlwaysUseMutable",
  "&&",
  "!",
  "Flags",
  ".",
  "isByVal",
  "(",
  ")",
  ";",
  "EVT",
  "ValVT",
  ";",
  "if",
  "(",
  "VA",
  ".",
  "getLocInfo",
  "(",
  ")",
  "==",
  "CCValAssign",
  "::",
  "Indirect",
  ")",
  "ValVT",
  "=",
  "VA",
  ".",
  "getLocVT",
  "(",
  ")",
  ";",
  "else",
  "ValVT",
  "=",
  "VA",
  ".",
  "getValVT",
  "(",
  ")",
  ";",
  "if",
  "(",
  "Flags",
  ".",
  "isByVal",
  "(",
  ")",
  ")",
  "{",
  "int",
  "FI",
  "=",
  "MFI",
  "->",
  "CreateFixedObject",
  "(",
  "Flags",
  ".",
  "getByValSize",
  "(",
  ")",
  ",",
  "VA",
  ".",
  "getLocMemOffset",
  "(",
  ")",
  ",",
  "isImmutable",
  ")",
  ";",
  "return",
  "DAG",
  ".",
  "getFrameIndex",
  "(",
  "FI",
  ",",
  "getPointerTy",
  "(",
  ")",
  ")",
  ";",
  "}",
  "else",
  "{"
] | 
| 
	LLVM | 
	X86 | 
	CPP | 
	next_suggestion | 
	CPU | 69 | 
	[
  "return",
  "DAG",
  ".",
  "getNode",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "dl",
  ",",
  "VT",
  ",",
  "Small",
  ",",
  "Overflow",
  ",",
  "Small",
  ")",
  ";"
] | 
	[
  "static",
  "SDValue",
  "expandFP_TO_UINT_SSE",
  "(",
  "MVT",
  "VT",
  ",",
  "SDValue",
  "Src",
  ",",
  "const",
  "SDLoc",
  "&",
  "dl",
  ",",
  "SelectionDAG",
  "&",
  "DAG",
  ",",
  "const",
  "X86Subtarget",
  "&",
  "Subtarget",
  ")",
  "{",
  "MVT",
  "SrcVT",
  "=",
  "Src",
  ".",
  "getSimpleValueType",
  "(",
  ")",
  ";",
  "unsigned",
  "DstBits",
  "=",
  "VT",
  ".",
  "getScalarSizeInBits",
  "(",
  ")",
  ";",
  "assert",
  "(",
  "DstBits",
  "==",
  "<NUM_LIT>",
  "&&",
  "<STR_LIT>",
  "expandFP_TO_UINT_SSE - only vXi32 supported",
  "<STR_LIT>",
  ")",
  ";",
  "SDValue",
  "Small",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "dl",
  ",",
  "VT",
  ",",
  "Src",
  ")",
  ";",
  "SDValue",
  "Big",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "dl",
  ",",
  "VT",
  ",",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "FSUB",
  ",",
  "dl",
  ",",
  "SrcVT",
  ",",
  "Src",
  ",",
  "DAG",
  ".",
  "getConstantFP",
  "(",
  "<NUM_LIT>",
  ",",
  "dl",
  ",",
  "SrcVT",
  ")",
  ")",
  ")",
  ";",
  "if",
  "(",
  "VT",
  "==",
  "MVT",
  "::",
  "v8i32",
  "&&",
  "!",
  "Subtarget",
  ".",
  "hasAVX2",
  "(",
  ")",
  ")",
  "{",
  "SDValue",
  "Overflow",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "OR",
  ",",
  "dl",
  ",",
  "VT",
  ",",
  "Small",
  ",",
  "Big",
  ")",
  ";"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 70 | 
	[
  "let",
  "InputType",
  "=",
  "<STR_LIT>",
  ";"
] | 
	[
  "def",
  "A4_cmphgt",
  ":",
  "HInst",
  "<",
  "(",
  "outs",
  "PredRegs",
  ":",
  "$",
  "Pd4",
  ")",
  ",",
  "(",
  "ins",
  "IntRegs",
  ":",
  "$",
  "Rs32",
  ",",
  "IntRegs",
  ":",
  "$",
  "Rt32",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "tc_85d5d03f",
  ",",
  "TypeS_3op",
  ">",
  ",",
  "Enc_c2b48e",
  ",",
  "ImmRegRel",
  "{",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "CextOpcode",
  "=",
  "<STR_LIT>",
  ";"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 71 | 
	[
  "let",
  "Defs",
  "=",
  "[",
  "USR_OVF",
  "]",
  ";"
] | 
	[
  "def",
  "A2_svsubhs",
  ":",
  "HInst",
  "<",
  "(",
  "outs",
  "IntRegs",
  ":",
  "$",
  "Rd32",
  ")",
  ",",
  "(",
  "ins",
  "IntRegs",
  ":",
  "$",
  "Rt32",
  ",",
  "IntRegs",
  ":",
  "$",
  "Rs32",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "tc_61830035",
  ",",
  "TypeALU32_3op",
  ">",
  ",",
  "Enc_bd6011",
  "{",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "hasNewValue",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "opNewValue",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "prefersSlot3",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	LLVM | 
	X86 | 
	CPP | 
	next_suggestion | 
	CPU | 72 | 
	[
  "}"
] | 
	[
  "SDValue",
  "Res",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "SCALAR_TO_VECTOR",
  ",",
  "dl",
  ",",
  "VecVT",
  ",",
  "N0",
  ")",
  ";",
  "Res",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ",",
  "dl",
  ",",
  "MVT",
  "::",
  "i32",
  ",",
  "Res",
  ")",
  ";",
  "Res",
  "=",
  "DAG",
  ".",
  "getZExtOrTrunc",
  "(",
  "Res",
  ",",
  "dl",
  ",",
  "VT",
  ")",
  ";",
  "Res",
  "=",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "AND",
  ",",
  "dl",
  ",",
  "VT",
  ",",
  "Res",
  ",",
  "DAG",
  ".",
  "getConstant",
  "(",
  "<NUM_LIT>",
  ",",
  "dl",
  ",",
  "VT",
  ")",
  ")",
  ";",
  "return",
  "Res",
  ";"
] | 
| 
	LLVM | 
	AMDGPU | 
	CPP | 
	next_suggestion | 
	GPU | 73 | 
	[
  "}"
] | 
	[
  "return",
  "&",
  "(",
  "*",
  "(",
  "--",
  "(",
  "Region",
  "->",
  "getEntry",
  "(",
  ")",
  "->",
  "getParent",
  "(",
  ")",
  "->",
  "end",
  "(",
  ")",
  ")",
  ")",
  ")",
  ";",
  "}",
  "MachineBasicBlock",
  "*",
  "LastMerge",
  "=",
  "MF",
  "->",
  "CreateMachineBasicBlock",
  "(",
  ")",
  ";",
  "if",
  "(",
  "Exit",
  "==",
  "nullptr",
  ")",
  "{",
  "MachineFunction",
  "::",
  "iterator",
  "ExitIter",
  "=",
  "MF",
  "->",
  "end",
  "(",
  ")",
  ";",
  "MF",
  "->",
  "insert",
  "(",
  "ExitIter",
  ",",
  "LastMerge",
  ")",
  ";",
  "}",
  "else",
  "{",
  "MachineFunction",
  "::",
  "iterator",
  "ExitIter",
  "=",
  "Exit",
  "->",
  "getIterator",
  "(",
  ")",
  ";",
  "MF",
  "->",
  "insert",
  "(",
  "ExitIter",
  ",",
  "LastMerge",
  ")",
  ";",
  "LastMerge",
  "->",
  "addSuccessor",
  "(",
  "Exit",
  ")",
  ";",
  "insertUnconditionalBranch",
  "(",
  "LastMerge",
  ",",
  "Exit",
  ")",
  ";",
  "LLVM_DEBUG",
  "(",
  "dbgs",
  "(",
  ")",
  "<<",
  "<STR_LIT>",
  "Created exit block: ",
  "<STR_LIT>",
  "<<",
  "LastMerge",
  "->",
  "getNumber",
  "(",
  ")",
  "<<",
  "<STR_LIT>",
  "\\n",
  "<STR_LIT>",
  ")",
  ";"
] | 
| 
	GCC | 
	arm | 
	MD | 
	next_suggestion | 
	CPU | 74 | 
	[
  "<STR_LIT>",
  ")"
] | 
	[
  "(",
  "define_insn_reservation",
  "<STR_LIT>",
  "<NUM_LIT>",
  "(",
  "and",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "eq_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  ")"
] | 
| 
	GCC | 
	h8300 | 
	MD | 
	stmt_completion | 
	MPU | 75 | 
	[
  "<STR_LIT>",
  ")",
  ")"
] | 
	[
  "(",
  "define_expand",
  "<STR_LIT>",
  "[",
  "(",
  "set",
  "(",
  "match_operand",
  ":",
  "HI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "mult",
  ":",
  "HI",
  "(",
  "zero_extend",
  ":",
  "HI",
  "(",
  "match_operand",
  ":",
  "QI",
  "<NUM_LIT>",
  "<STR_LIT>"
] | 
| 
	GCC | 
	frv | 
	MD | 
	next_suggestion | 
	VLIW | 76 | 
	[
  "[",
  "(",
  "set_attr",
  "<STR_LIT>",
  "<STR_LIT>",
  ")"
] | 
	[
  "(",
  "match_operand",
  ":",
  "HI",
  "<NUM_LIT>",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "]",
  "UNSPEC_MPACKH",
  ")",
  ")",
  "]",
  "<STR_LIT>",
  "<STR_LIT>"
] | 
| 
	GCC | 
	rs6000 | 
	MD | 
	stmt_completion | 
	CPU | 77 | 
	[
  "<STR_LIT>",
  "<STR_LIT>",
  ")"
] | 
	[
  "(",
  "define_cpu_unit",
  "<STR_LIT>",
  "<STR_LIT>",
  ")",
  "(",
  "define_cpu_unit"
] | 
| 
	GCC | 
	aarch64 | 
	MD | 
	stmt_completion | 
	CPU | 78 | 
	[
  "]",
  ")"
] | 
	[
  "(",
  "define_code_iterator",
  "ANY_EXTEND",
  "[",
  "sign_extend",
  "zero_extend",
  "]",
  ")",
  "(",
  "define_code_iterator",
  "ANY_EXTEND2",
  "[",
  "sign_extend",
  "zero_extend"
] | 
| 
	LLVM | 
	SystemZ | 
	TD | 
	stmt_completion | 
	CPU | 79 | 
	[
  "CCValues",
  ";"
] | 
	[
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "CompareZeroCCMask",
  "=",
  "<NUM_LIT>",
  ";",
  "bit",
  "CCMaskFirst",
  "=",
  "<NUM_LIT>",
  ";",
  "bit",
  "CCMaskLast",
  "=",
  "<NUM_LIT>",
  ";",
  "bit",
  "IsLogical",
  "=",
  "<NUM_LIT>",
  ";",
  "bit",
  "CCIfNoSignedWrap",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "TSFlags",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "SimpleBDXLoad",
  ";",
  "let",
  "TSFlags",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "SimpleBDXStore",
  ";",
  "let",
  "TSFlags",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "Has20BitOffset",
  ";",
  "let",
  "TSFlags",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "HasIndex",
  ";",
  "let",
  "TSFlags",
  "{",
  "<NUM_LIT>",
  "}",
  "=",
  "Is128Bit",
  ";",
  "let",
  "TSFlags",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "AccessBytes",
  ";",
  "let",
  "TSFlags",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "="
] | 
| 
	LLVM | 
	PowerPC | 
	CPP | 
	code_generation | 
	CPU | 80 | 
	[
  "void",
  "PPCRegisterInfo",
  "::",
  "eliminateFrameIndex",
  "(",
  "MachineBasicBlock",
  "::",
  "iterator",
  "II",
  ",",
  "int",
  "SPAdj",
  ",",
  "unsigned",
  "FIOperandNum",
  ",",
  "RegScavenger",
  "*",
  "RS",
  ")",
  "const",
  "{",
  "assert",
  "(",
  "SPAdj",
  "==",
  "<NUM_LIT>",
  "&&",
  "<STR_LIT>",
  "Unexpected",
  "<STR_LIT>",
  ")",
  ";",
  "MachineInstr",
  "&",
  "MI",
  "=",
  "*",
  "II",
  ";",
  "MachineBasicBlock",
  "&",
  "MBB",
  "=",
  "*",
  "MI",
  ".",
  "getParent",
  "(",
  ")",
  ";",
  "MachineFunction",
  "&",
  "MF",
  "=",
  "*",
  "MBB",
  ".",
  "getParent",
  "(",
  ")",
  ";",
  "const",
  "TargetInstrInfo",
  "&",
  "TII",
  "=",
  "*",
  "MF",
  ".",
  "getSubtarget",
  "(",
  ")",
  ".",
  "getInstrInfo",
  "(",
  ")",
  ";",
  "MachineFrameInfo",
  "*",
  "MFI",
  "=",
  "MF",
  ".",
  "getFrameInfo",
  "(",
  ")",
  ";",
  "DebugLoc",
  "dl",
  "=",
  "MI",
  ".",
  "getDebugLoc",
  "(",
  ")",
  ";",
  "unsigned",
  "OffsetOperandNo",
  "=",
  "getOffsetONFromFION",
  "(",
  "MI",
  ",",
  "FIOperandNum",
  ")",
  ";",
  "int",
  "FrameIndex",
  "=",
  "MI",
  ".",
  "getOperand",
  "(",
  "FIOperandNum",
  ")",
  ".",
  "getIndex",
  "(",
  ")",
  ";",
  "PPCFunctionInfo",
  "*",
  "FI",
  "=",
  "MF",
  ".",
  "getInfo",
  "<",
  "PPCFunctionInfo",
  ">",
  "(",
  ")",
  ";",
  "int",
  "FPSI",
  "=",
  "FI",
  "->",
  "getFramePointerSaveIndex",
  "(",
  ")",
  ";",
  "unsigned",
  "OpC",
  "=",
  "MI",
  ".",
  "getOpcode",
  "(",
  ")",
  ";",
  "if",
  "(",
  "FPSI",
  "&&",
  "FrameIndex",
  "==",
  "FPSI",
  "&&",
  "(",
  "OpC",
  "==",
  "PPC",
  "::",
  "DYNALLOC",
  "||",
  "OpC",
  "==",
  "PPC",
  "::",
  "DYNALLOC8",
  ")",
  ")",
  "{",
  "lowerDynamicAlloc",
  "(",
  "II",
  ")",
  ";",
  "return",
  ";",
  "}",
  "if",
  "(",
  "OpC",
  "==",
  "PPC",
  "::",
  "SPILL_CR",
  ")",
  "{",
  "lowerCRSpilling",
  "(",
  "II",
  ",",
  "FrameIndex",
  ")",
  ";",
  "return",
  ";",
  "}",
  "else",
  "if",
  "(",
  "OpC",
  "==",
  "PPC",
  "::",
  "RESTORE_CR",
  ")",
  "{",
  "lowerCRRestore",
  "(",
  "II",
  ",",
  "FrameIndex",
  ")",
  ";",
  "return",
  ";",
  "}",
  "else",
  "if",
  "(",
  "OpC",
  "==",
  "PPC",
  "::",
  "SPILL_CRBIT",
  ")",
  "{",
  "lowerCRBitSpilling",
  "(",
  "II",
  ",",
  "FrameIndex",
  ")",
  ";",
  "return",
  ";",
  "}",
  "else",
  "if",
  "(",
  "OpC",
  "==",
  "PPC",
  "::",
  "RESTORE_CRBIT",
  ")",
  "{",
  "lowerCRBitRestore",
  "(",
  "II",
  ",",
  "FrameIndex",
  ")",
  ";",
  "return",
  ";",
  "}",
  "else",
  "if",
  "(",
  "OpC",
  "==",
  "PPC",
  "::",
  "SPILL_VRSAVE",
  ")",
  "{",
  "lowerVRSAVESpilling",
  "(",
  "II",
  ",",
  "FrameIndex",
  ")",
  ";",
  "return",
  ";",
  "}",
  "else",
  "if",
  "(",
  "OpC",
  "==",
  "PPC",
  "::",
  "RESTORE_VRSAVE",
  ")",
  "{",
  "lowerVRSAVERestore",
  "(",
  "II",
  ",",
  "FrameIndex",
  ")",
  ";",
  "return",
  ";",
  "}",
  "MI",
  ".",
  "getOperand",
  "(",
  "FIOperandNum",
  ")",
  ".",
  "ChangeToRegister",
  "(",
  "FrameIndex",
  "<",
  "<NUM_LIT>",
  "?",
  "getBaseRegister",
  "(",
  "MF",
  ")",
  ":",
  "getFrameRegister",
  "(",
  "MF",
  ")",
  ",",
  "false",
  ")",
  ";",
  "bool",
  "isIXAddr",
  "=",
  "usesIXAddr",
  "(",
  "MI",
  ")",
  ";",
  "bool",
  "noImmForm",
  "=",
  "!",
  "MI",
  ".",
  "isInlineAsm",
  "(",
  ")",
  "&&",
  "!",
  "ImmToIdxMap",
  ".",
  "count",
  "(",
  "OpC",
  ")",
  ";",
  "int",
  "Offset",
  "=",
  "MFI",
  "->",
  "getObjectOffset",
  "(",
  "FrameIndex",
  ")",
  ";",
  "Offset",
  "+=",
  "MI",
  ".",
  "getOperand",
  "(",
  "OffsetOperandNo",
  ")",
  ".",
  "getImm",
  "(",
  ")",
  ";",
  "if",
  "(",
  "!",
  "MF",
  ".",
  "getFunction",
  "(",
  ")",
  "->",
  "getAttributes",
  "(",
  ")",
  ".",
  "hasAttribute",
  "(",
  "AttributeSet",
  "::",
  "FunctionIndex",
  ",",
  "Attribute",
  "::",
  "Naked",
  ")",
  ")",
  "{",
  "if",
  "(",
  "!",
  "(",
  "hasBasePointer",
  "(",
  "MF",
  ")",
  "&&",
  "FrameIndex",
  "<",
  "<NUM_LIT>",
  ")",
  ")",
  "Offset",
  "+=",
  "MFI",
  "->",
  "getStackSize",
  "(",
  ")",
  ";",
  "}",
  "assert",
  "(",
  "OpC",
  "!=",
  "PPC",
  "::",
  "DBG_VALUE",
  "&&",
  "<STR_LIT>",
  "This should be handle in a target independent way",
  "<STR_LIT>",
  ")",
  ";",
  "if",
  "(",
  "!",
  "noImmForm",
  "&&",
  "isInt",
  "<",
  "<NUM_LIT>",
  ">",
  "(",
  "Offset",
  ")",
  "&&",
  "(",
  "!",
  "isIXAddr",
  "||",
  "(",
  "Offset",
  "&",
  "<NUM_LIT>",
  ")",
  "==",
  "<NUM_LIT>",
  ")",
  ")",
  "{",
  "MI",
  ".",
  "getOperand",
  "(",
  "OffsetOperandNo",
  ")",
  ".",
  "ChangeToImmediate",
  "(",
  "Offset",
  ")",
  ";",
  "return",
  ";",
  "}",
  "bool",
  "is64Bit",
  "=",
  "Subtarget",
  ".",
  "isPPC64",
  "(",
  ")",
  ";",
  "const",
  "TargetRegisterClass",
  "*",
  "G8RC",
  "=",
  "&",
  "PPC",
  "::",
  "G8RCRegClass",
  ";",
  "const",
  "TargetRegisterClass",
  "*",
  "GPRC",
  "=",
  "&",
  "PPC",
  "::",
  "GPRCRegClass",
  ";",
  "const",
  "TargetRegisterClass",
  "*",
  "RC",
  "=",
  "is64Bit",
  "?",
  "G8RC",
  ":",
  "GPRC",
  ";",
  "unsigned",
  "SRegHi",
  "=",
  "MF",
  ".",
  "getRegInfo",
  "(",
  ")",
  ".",
  "createVirtualRegister",
  "(",
  "RC",
  ")",
  ",",
  "SReg",
  "=",
  "MF",
  ".",
  "getRegInfo",
  "(",
  ")",
  ".",
  "createVirtualRegister",
  "(",
  "RC",
  ")",
  ";",
  "BuildMI",
  "(",
  "MBB",
  ",",
  "II",
  ",",
  "dl",
  ",",
  "TII",
  ".",
  "get",
  "(",
  "is64Bit",
  "?",
  "PPC",
  "::",
  "LIS8",
  ":",
  "PPC",
  "::",
  "LIS",
  ")",
  ",",
  "SRegHi",
  ")",
  ".",
  "addImm",
  "(",
  "Offset",
  ">>",
  "<NUM_LIT>",
  ")",
  ";",
  "BuildMI",
  "(",
  "MBB",
  ",",
  "II",
  ",",
  "dl",
  ",",
  "TII",
  ".",
  "get",
  "(",
  "is64Bit",
  "?",
  "PPC",
  "::",
  "ORI8",
  ":",
  "PPC",
  "::",
  "ORI",
  ")",
  ",",
  "SReg",
  ")",
  ".",
  "addReg",
  "(",
  "SRegHi",
  ",",
  "RegState",
  "::",
  "Kill",
  ")",
  ".",
  "addImm",
  "(",
  "Offset",
  ")",
  ";",
  "unsigned",
  "OperandBase",
  ";",
  "if",
  "(",
  "noImmForm",
  ")",
  "OperandBase",
  "=",
  "<NUM_LIT>",
  ";",
  "else",
  "if",
  "(",
  "OpC",
  "!=",
  "TargetOpcode",
  "::",
  "INLINEASM",
  ")",
  "{",
  "assert",
  "(",
  "ImmToIdxMap",
  ".",
  "count",
  "(",
  "OpC",
  ")",
  "&&",
  "<STR_LIT>",
  "No indexed form of load or store available!",
  "<STR_LIT>",
  ")",
  ";",
  "unsigned",
  "NewOpcode",
  "=",
  "ImmToIdxMap",
  ".",
  "find",
  "(",
  "OpC",
  ")",
  "->",
  "second",
  ";",
  "MI",
  ".",
  "setDesc",
  "(",
  "TII",
  ".",
  "get",
  "(",
  "NewOpcode",
  ")",
  ")",
  ";",
  "OperandBase",
  "=",
  "<NUM_LIT>",
  ";",
  "}",
  "else",
  "{",
  "OperandBase",
  "=",
  "OffsetOperandNo",
  ";",
  "}",
  "unsigned",
  "StackReg",
  "=",
  "MI",
  ".",
  "getOperand",
  "(",
  "FIOperandNum",
  ")",
  ".",
  "getReg",
  "(",
  ")",
  ";",
  "MI",
  ".",
  "getOperand",
  "(",
  "OperandBase",
  ")",
  ".",
  "ChangeToRegister",
  "(",
  "StackReg",
  ",",
  "false",
  ")",
  ";",
  "MI",
  ".",
  "getOperand",
  "(",
  "OperandBase",
  "+",
  "<NUM_LIT>",
  ")",
  ".",
  "ChangeToRegister",
  "(",
  "SReg",
  ",",
  "false",
  ",",
  "false",
  ",",
  "true",
  ")",
  ";",
  "}"
] | 
	[
  "This",
  "method",
  "must",
  "be",
  "overriden",
  "to",
  "eliminate",
  "abstract",
  "frame",
  "indices",
  "from",
  "instructions",
  "which",
  "may",
  "use",
  "them",
  "."
] | 
| 
	LLVM | 
	PowerPC | 
	CPP | 
	next_suggestion | 
	CPU | 81 | 
	[
  "++",
  "Result",
  ";"
] | 
	[
  "unsigned",
  "Shift",
  "=",
  "<NUM_LIT>",
  ";",
  "if",
  "(",
  "!",
  "isInt",
  "<",
  "<NUM_LIT>",
  ">",
  "(",
  "Imm",
  ")",
  ")",
  "{",
  "Shift",
  "=",
  "countTrailingZeros",
  "<",
  "uint64_t",
  ">",
  "(",
  "Imm",
  ")",
  ";",
  "int64_t",
  "ImmSh",
  "=",
  "static_cast",
  "<",
  "uint64_t",
  ">",
  "(",
  "Imm",
  ")",
  ">>",
  "Shift",
  ";",
  "if",
  "(",
  "isInt",
  "<",
  "<NUM_LIT>",
  ">",
  "(",
  "ImmSh",
  ")",
  ")",
  "{",
  "Imm",
  "=",
  "ImmSh",
  ";",
  "}",
  "else",
  "{",
  "Remainder",
  "=",
  "Imm",
  ";",
  "Shift",
  "=",
  "<NUM_LIT>",
  ";",
  "Imm",
  ">>=",
  "<NUM_LIT>",
  ";",
  "}",
  "}",
  "unsigned",
  "Result",
  "=",
  "<NUM_LIT>",
  ";",
  "unsigned",
  "Lo",
  "=",
  "Imm",
  "&",
  "<NUM_LIT>",
  ";",
  "if",
  "(",
  "isInt",
  "<",
  "<NUM_LIT>",
  ">",
  "(",
  "Imm",
  ")",
  ")",
  "{"
] | 
| 
	GCC | 
	i386 | 
	CPP | 
	stmt_completion | 
	CPU | 82 | 
	[
  ";"
] | 
	[
  "bool",
  "ix86_function_value_regno_p",
  "(",
  "int",
  "regno",
  ")",
  "{",
  "if",
  "(",
  "regno",
  "==",
  "<NUM_LIT>",
  "||",
  "(",
  "regno",
  "==",
  "FIRST_FLOAT_REG",
  "&&",
  "TARGET_FLOAT_RETURNS_IN_80387",
  ")",
  "||",
  "(",
  "regno",
  "==",
  "FIRST_SSE_REG",
  "&&",
  "TARGET_SSE",
  ")",
  ")",
  "return",
  "true",
  ";",
  "if",
  "(",
  "!",
  "TARGET_64BIT",
  "&&",
  "(",
  "regno",
  "==",
  "FIRST_MMX_REG",
  "&&",
  "TARGET_MMX",
  ")",
  ")",
  "return",
  "true",
  ";",
  "return",
  "false"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 83 | 
	[
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Rx32",
  ";"
] | 
	[
  "class",
  "Enc_d15d19",
  ":",
  "OpcodeHexagon",
  "{",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Mu2",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Mu2",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Vs32",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Vs32",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  ";"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 84 | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";"
] | 
	[
  "def",
  "C2_or",
  ":",
  "HInst",
  "<",
  "(",
  "outs",
  "PredRegs",
  ":",
  "$",
  "Pd4",
  ")",
  ",",
  "(",
  "ins",
  "PredRegs",
  ":",
  "$",
  "Pt4",
  ",",
  "PredRegs",
  ":",
  "$",
  "Ps4",
  ")",
  ",",
  "<STR_LIT>",
  ",",
  "tc_640086b5",
  ",",
  "TypeCR",
  ">",
  ",",
  "Enc_454a26",
  "{",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	LLVM | 
	Lanai | 
	CPP | 
	next_suggestion | 
	CPU | 85 | 
	[
  "}"
] | 
	[
  "}",
  "void",
  "Lower",
  "(",
  "const",
  "MachineInstr",
  "*",
  "MI",
  ",",
  "MCInst",
  "&",
  "OutMI",
  ")",
  "const",
  ";",
  "MCOperand",
  "LowerSymbolOperand",
  "(",
  "const",
  "MachineOperand",
  "&",
  "MO",
  ",",
  "MCSymbol",
  "*",
  "Sym",
  ")",
  "const",
  ";",
  "MCSymbol",
  "*",
  "GetGlobalAddressSymbol",
  "(",
  "const",
  "MachineOperand",
  "&",
  "MO",
  ")",
  "const",
  ";",
  "MCSymbol",
  "*",
  "GetBlockAddressSymbol",
  "(",
  "const",
  "MachineOperand",
  "&",
  "MO",
  ")",
  "const",
  ";",
  "MCSymbol",
  "*",
  "GetExternalSymbolSymbol",
  "(",
  "const",
  "MachineOperand",
  "&",
  "MO",
  ")",
  "const",
  ";",
  "MCSymbol",
  "*",
  "GetJumpTableSymbol",
  "(",
  "const",
  "MachineOperand",
  "&",
  "MO",
  ")",
  "const",
  ";",
  "MCSymbol",
  "*",
  "GetConstantPoolIndexSymbol",
  "(",
  "const",
  "MachineOperand",
  "&",
  "MO",
  ")",
  "const",
  ";"
] | 
| 
	LLVM | 
	X86 | 
	CPP | 
	next_suggestion | 
	CPU | 86 | 
	[
  "OpcodeSelect",
  "=",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ";"
] | 
	[
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":",
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":",
  "return",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "AND",
  ",",
  "dl",
  ",",
  "VT",
  ",",
  "Op",
  ",",
  "VMask",
  ")",
  ";",
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":",
  "return",
  "DAG",
  ".",
  "getNode",
  "(",
  "ISD",
  "::",
  "OR",
  ",",
  "dl",
  ",",
  "VT",
  ",",
  "Op",
  ",",
  "VMask",
  ")",
  ";",
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":",
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":",
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":",
  "case",
  "<STR_LIT>",
  "::",
  "<STR_LIT>",
  ":"
] | 
| 
	GCC | 
	i386 | 
	CPP | 
	code_generation | 
	CPU | 87 | 
	[
  "bool",
  "symbolic_reference_mentioned_p",
  "(",
  "rtx",
  "op",
  ")",
  "{",
  "const",
  "char",
  "*",
  "fmt",
  ";",
  "int",
  "i",
  ";",
  "if",
  "(",
  "GET_CODE",
  "(",
  "op",
  ")",
  "==",
  "SYMBOL_REF",
  "||",
  "GET_CODE",
  "(",
  "op",
  ")",
  "==",
  "LABEL_REF",
  ")",
  "return",
  "true",
  ";",
  "fmt",
  "=",
  "GET_RTX_FORMAT",
  "(",
  "GET_CODE",
  "(",
  "op",
  ")",
  ")",
  ";",
  "for",
  "(",
  "i",
  "=",
  "GET_RTX_LENGTH",
  "(",
  "GET_CODE",
  "(",
  "op",
  ")",
  ")",
  "-",
  "<NUM_LIT>",
  ";",
  "i",
  ">=",
  "<NUM_LIT>",
  ";",
  "i",
  "--",
  ")",
  "{",
  "if",
  "(",
  "fmt",
  "[",
  "i",
  "]",
  "==",
  "'",
  "E",
  "'",
  ")",
  "{",
  "int",
  "j",
  ";",
  "for",
  "(",
  "j",
  "=",
  "XVECLEN",
  "(",
  "op",
  ",",
  "i",
  ")",
  "-",
  "<NUM_LIT>",
  ";",
  "j",
  ">=",
  "<NUM_LIT>",
  ";",
  "j",
  "--",
  ")",
  "if",
  "(",
  "symbolic_reference_mentioned_p",
  "(",
  "XVECEXP",
  "(",
  "op",
  ",",
  "i",
  ",",
  "j",
  ")",
  ")",
  ")",
  "return",
  "true",
  ";",
  "}",
  "else",
  "if",
  "(",
  "fmt",
  "[",
  "i",
  "]",
  "==",
  "'",
  "e",
  "'",
  "&&",
  "symbolic_reference_mentioned_p",
  "(",
  "XEXP",
  "(",
  "op",
  ",",
  "i",
  ")",
  ")",
  ")",
  "return",
  "true",
  ";",
  "}",
  "return",
  "false",
  ";",
  "}"
] | 
	[
  "Return",
  "true",
  "if",
  "OP",
  "contains",
  "a",
  "symbol",
  "reference"
] | 
| 
	GCC | 
	rs6000 | 
	CPP | 
	stmt_completion | 
	CPU | 88 | 
	[
  "rtx",
  "*",
  "str_mem",
  ")",
  "{"
] | 
	[
  "static",
  "bool",
  "is_store_insn",
  "(",
  "rtx",
  "insn",
  ","
] | 
| 
	LLVM | 
	AMDGPU | 
	CPP | 
	next_suggestion | 
	GPU | 89 | 
	[
  "return",
  "false",
  ";"
] | 
	[
  "Id",
  "=",
  "toFuncId",
  "(",
  "Loc",
  "->",
  "second",
  ")",
  ";",
  "return",
  "true",
  ";",
  "}",
  "Id",
  "=",
  "AMDGPULibFunc",
  "::",
  "EI_NONE",
  ";"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 90 | 
	[
  "let",
  "isTaken",
  "=",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  ";"
] | 
	[
  "let",
  "isPredicatedNew",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofRelax1",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofRelax2",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "cofMax1",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Defs",
  "=",
  "[",
  "PC",
  "]",
  ";"
] | 
| 
	LLVM | 
	R600 | 
	CPP | 
	next_suggestion | 
	GPU | 91 | 
	[
  "}"
] | 
	[
  "bool",
  "programSpillsRegisters",
  "(",
  ")",
  "{",
  "return",
  "!",
  "SpilledRegisters",
  ".",
  "empty",
  "(",
  ")",
  ";"
] | 
| 
	LLVM | 
	AArch64 | 
	TD | 
	stmt_completion | 
	CPU | 92 | 
	[
  "<NUM_LIT>",
  ";"
] | 
	[
  "def",
  "Xrs",
  ":",
  "BaseAddSubSReg",
  "<",
  "isSub",
  ",",
  "<NUM_LIT>",
  ",",
  "GPR64",
  ",",
  "arith_shifted_reg64",
  ",",
  "mnemonic",
  ",",
  "OpNode",
  ">",
  "{",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "}",
  "="
] | 
| 
	LLVM | 
	ARM | 
	TD | 
	stmt_completion | 
	CPU | 93 | 
	[
  ";"
] | 
	[
  "def",
  "VecListThreeDByteIndexAsmOperand",
  ":",
  "AsmOperandClass",
  "{",
  "let",
  "Name",
  "=",
  "<STR_LIT>",
  ";",
  "let",
  "ParserMethod",
  "=",
  "<STR_LIT>"
] | 
| 
	LLVM | 
	AArch64 | 
	TD | 
	next_suggestion | 
	CPU | 94 | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "opc",
  ";"
] | 
	[
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Rd",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Rn",
  ";",
  "bits",
  "<",
  "<NUM_LIT>",
  ">",
  "Rm",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "Rm",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	LLVM | 
	Hexagon | 
	TD | 
	next_suggestion | 
	DSP | 95 | 
	[
  "let",
  "cofRelax1",
  "=",
  "<NUM_LIT>",
  ";"
] | 
	[
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "Inst",
  "{",
  "<NUM_LIT>",
  "-",
  "<NUM_LIT>",
  "}",
  "=",
  "<NUM_LIT>",
  ";",
  "let",
  "isPredicateLate",
  "=",
  "<NUM_LIT>",
  ";"
] | 
| 
	LLVM | 
	AMDGPU | 
	CPP | 
	next_suggestion | 
	GPU | 96 | 
	[
  "break",
  ";"
] | 
	[
  "const",
  "GCNSubtarget",
  "&",
  "ST",
  "=",
  "MF",
  ".",
  "getSubtarget",
  "<",
  "GCNSubtarget",
  ">",
  "(",
  ")",
  ";",
  "TII",
  "=",
  "ST",
  ".",
  "getInstrInfo",
  "(",
  ")",
  ";",
  "TRI",
  "=",
  "&",
  "TII",
  "->",
  "getRegisterInfo",
  "(",
  ")",
  ";",
  "MDT",
  "=",
  "&",
  "getAnalysis",
  "<",
  "MachineDominatorTree",
  ">",
  "(",
  ")",
  ";",
  "SkipThreshold",
  "=",
  "SkipThresholdFlag",
  ";",
  "MachineBasicBlock",
  "*",
  "EmptyMBBAtEnd",
  "=",
  "nullptr",
  ";",
  "SmallVector",
  "<",
  "MachineInstr",
  "*",
  ",",
  "<NUM_LIT>",
  ">",
  "KillInstrs",
  ";",
  "bool",
  "MadeChange",
  "=",
  "false",
  ";",
  "for",
  "(",
  "MachineBasicBlock",
  "&",
  "MBB",
  ":",
  "MF",
  ")",
  "{",
  "MachineBasicBlock",
  "::",
  "iterator",
  "I",
  ",",
  "Next",
  ";",
  "for",
  "(",
  "I",
  "=",
  "MBB",
  ".",
  "begin",
  "(",
  ")",
  ";",
  "I",
  "!=",
  "MBB",
  ".",
  "end",
  "(",
  ")",
  ";",
  "I",
  "=",
  "Next",
  ")",
  "{",
  "Next",
  "=",
  "std",
  "::",
  "next",
  "(",
  "I",
  ")",
  ";",
  "MachineInstr",
  "&",
  "MI",
  "=",
  "*",
  "I",
  ";",
  "switch",
  "(",
  "MI",
  ".",
  "getOpcode",
  "(",
  ")",
  ")",
  "{",
  "case",
  "AMDGPU",
  "::",
  "SI_MASK_BRANCH",
  ":",
  "MadeChange",
  "|=",
  "skipMaskBranch",
  "(",
  "MI",
  ",",
  "MBB",
  ")",
  ";",
  "break",
  ";",
  "case",
  "AMDGPU",
  "::",
  "S_BRANCH",
  ":",
  "if",
  "(",
  "MBB",
  ".",
  "isLayoutSuccessor",
  "(",
  "MI",
  ".",
  "getOperand",
  "(",
  "<NUM_LIT>",
  ")",
  ".",
  "getMBB",
  "(",
  ")",
  ")",
  ")",
  "{",
  "assert",
  "(",
  "&",
  "MI",
  "==",
  "&",
  "MBB",
  ".",
  "back",
  "(",
  ")",
  ")",
  ";",
  "MI",
  ".",
  "eraseFromParent",
  "(",
  ")",
  ";",
  "MadeChange",
  "=",
  "true",
  ";",
  "}"
] | 
| 
	GCC | 
	arm | 
	MD | 
	stmt_completion | 
	CPU | 97 | 
	[
  "<",
  "V_mode_nunits",
  ">",
  "/",
  "<NUM_LIT>",
  ")",
  "+",
  "i",
  ")"
] | 
	[
  "for",
  "(",
  "i",
  "=",
  "<NUM_LIT>",
  "RTVEC_ELT",
  "(",
  "v",
  ",",
  "i",
  ")",
  "=",
  "GEN_INT",
  "(",
  "("
] | 
| 
	GCC | 
	i386 | 
	CPP | 
	stmt_completion | 
	CPU | 98 | 
	[
  "_",
  "_",
  "i0",
  ",",
  "_",
  "_",
  "i1",
  ")",
  ";"
] | 
	[
  "return",
  "(",
  "_",
  "_",
  "m64",
  ")",
  "_",
  "_",
  "builtin_ia32_vec_init_v2si",
  "("
] | 
| 
	GCC | 
	i386 | 
	CPP | 
	stmt_completion | 
	CPU | 99 | 
	[
  "_",
  "_",
  "LY",
  ",",
  "const",
  "int",
  "_",
  "_",
  "M",
  ")",
  "{"
] | 
	[
  "extern",
  "_",
  "_",
  "inline",
  "int",
  "_",
  "_",
  "attribute__",
  "(",
  "(",
  "_",
  "_",
  "gnu_inline__",
  ",",
  "_",
  "_",
  "always_inline__",
  ",",
  "_",
  "_",
  "artificial__",
  ")",
  ")",
  "_",
  "mm_cmpestrc",
  "(",
  "_",
  "_",
  "m128i",
  "_",
  "_",
  "X",
  ",",
  "int",
  "_",
  "_",
  "LX",
  ",",
  "_",
  "_",
  "m128i",
  "_",
  "_",
  "Y",
  ",",
  "int"
] | 
End of preview. Expand
						in Data Studio
					
	ComBack++: A Multi-Language Dataset Providing End-to-End Support for Compiler Backend Development
ComBack++ is a large-scale, multi-platform and multi-language compiler backend code dataset. It is sourced from GCC and LLVM backends corresponding to 183 target platforms.
Dataset Information
- Source Data - GCC
 - Category - Target Platform - C++ Function - C++ KLoC - Machine Description KLoC - CPU - 30 - 56,211 - 858.2 - 228.5 - MPU - 35 - 8,713 - 243.8 - 87.1 - GPU - 2 - 731 - 12.7 - 3.0 - VLIW - 5 - 1,323 - 32.8 - 17.8 - DSP - 4 - 542 - 17.2 - 6.1 - Virtual - 5 - 558 - 10.5 - 0.1 - SUM - 81 - 68,078 - 1175.2 - 342.6 - LLVM
 - Category - Target Platform - C++ Function - C++ KLoC - TableGen KLoC - CPU - 43 - 97,972 - 3,768.4 - 1,157.7 - MPU - 30 - 12,552 - 190.7 - 24.8 - GPU - 5 - 28,267 - 886.8 - 168.5 - VLIW - 5 - 2,386 - 27.4 - 0.8 - DSP - 7 - 11,584 - 296.8 - 129.4 - Virtual - 12 - 10,538 - 199.4 - 12.9 - SUM - 102 - 163,299 - 5,369.5 - 1,494.1 
- Tasks - Statement-Level Completion: complete current statement.
 - //Inputs: ... adjustReg(MBB,LastFrameDestroy, DL, SPReg, FPReg, -StackSize+RVFI->getVarArgsSaveSize() //Ground Truth: MachineInstr::FrameDestroy);- Next-Statement Suggestion: predict the next statement.
 - //Inputs: ... maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask; //Ground Truth: MFI -> setMaxCallFrameSize(maxCallFrameSize);- Code Generation: generate a function template with function description in natrual language.
 - //Inputs: getPointerRegClass: Returns a TargetRegisterClass used for pointer values. //Ground Truth: TargetRegisterClass *RegisterInfo::getPointerRegClass(MachineFunction &MF ,unsigned Kind) { return Subtarget.is64Bit() ? <ISA_LIT> : <ISA_LIT>; }- Program Repair: automatically fixing bugs at identified locations.
 - //Inputs: int64_t Imm; <BUGS> MCExpr::VariantKind VK; <BUGE> ... //Ground Truth: <FIXS> MCExpr::VariantKind VK = MCExpr::VK_None; <FIXE>
Organization
- ./*.jsonl: Take data of RISC-V,ARC,NVPTX both in GCC and LLVM as test set, split train/valid set in the ratio of 90%:10% of other targets excluding RI5CY(RI5CY is custmoized based on RISCV)- Task - Programming Language - Train - Valid - Test - Statement-Level Completion - C++ - 149,368 (16.41M) - 16,480 (1.84M) - 7,897 (0.82M) - Statement-Level Completion - TableGen/MD - 120,460 (4.46M) - 13,295 (0.50M) - 7,090 (0.25M) - Next-Statement Suggestion - C++ - 137,155 (20.55M) - 15,218 (2.32M) - 8,109 (1.09M) - Next-Statement Suggestion - TableGen/MD - 124,528 (6.71M) - 14,009 (0.76M) - 2,726 (0.14M) - Code Generation - C++ - 37,805 (10.69M) - 4,137 (1.16M) - 2,944 (0.73M) - Program Repair - C++ - 40,578 (4.33M) - 4,539 (0.48M) - 2,623 (0.29M) - Program Repair - TableGen/MD - 25,983 (2.95M) - 2,975 (0.33M) - 1,814 (0.24M) 
Citation
@article{zhong2025bepilot,
author = {Zhong, Ming and Sun, Xin and Lv, Fang and Wang, Lulin and Geng, Hongna and Qiu, Lei and Cui, Huimin and Feng, Xiaobing},
title = {BePilot: An AI Programming Assistant for Compiler Backend Development},
year = {2025},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
issn = {1049-331X},
url = {https://doi.org/10.1145/3764585},
doi = {10.1145/3764585},
note = {Just Accepted},
journal = {ACM Trans. Softw. Eng. Methodol.}
}
- Downloads last month
- 20
