diff --git a/compiler_gym/third_party/inst2vec/inst2vec_preprocess.py b/compiler_gym/third_party/inst2vec/inst2vec_preprocess.py
index 3c75706ac..3a07f0fca 100644
--- a/compiler_gym/third_party/inst2vec/inst2vec_preprocess.py
+++ b/compiler_gym/third_party/inst2vec/inst2vec_preprocess.py
@@ -339,16 +339,16 @@ def preprocess(data):
 # XFG-transforming (inline and abstract statements)
 ########################################################################################################################
 # Helper regexs for structure type inlining
-vector_type = "<\d+ x " + rgx.first_class_type + ">"
-array_type = "\[\d+ x " + rgx.first_class_type + "\]"
-array_of_array_type = "\[\d+ x " + "\[\d+ x " + rgx.first_class_type + "\]" + "\]"
+vector_type = r"<\d+ x " + rgx.first_class_type + r">"
+array_type = r"\[\d+ x " + rgx.first_class_type + r"\]"
+array_of_array_type = r"\[\d+ x " + r"\[\d+ x " + rgx.first_class_type + r"\]" + r"\]"
 function_type = (
     rgx.first_class_type
-    + " \("
+    + r" \("
     + rgx.any_of([rgx.first_class_type, vector_type, array_type, "..."], ",")
     + "*"
     + rgx.any_of([rgx.first_class_type, vector_type, array_type, "..."])
-    + "\)\**"
+    + r"\)\**"
 )
 structure_entry = rgx.any_of(
     [
@@ -460,7 +460,7 @@ def construct_struct_types_dictionary_for_file(data):
             struct_prev.append(comp_structure)
             struct_prev_with_comma.append(comp_structure + ", ")
         else:
-            comp_structure = "<?{ [ <>{}\dx\[\]\(\)\.,\*%IDvfloatdubeipqcy]+}>?$"
+            comp_structure = r"<?{ [ <>{}\dx\[\]\(\)\.,\*%IDvfloatdubeipqcy]+}>?$"
 
         # Loop over contents of to_process
         for i in list(to_process.items()):
diff --git a/compiler_gym/third_party/inst2vec/rgx_utils.py b/compiler_gym/third_party/inst2vec/rgx_utils.py
index c6f11a32a..9454ece10 100644
--- a/compiler_gym/third_party/inst2vec/rgx_utils.py
+++ b/compiler_gym/third_party/inst2vec/rgx_utils.py
@@ -29,58 +29,58 @@
 # Regex manipulation: helper functions
 ########################################################################################################################
 def any_of(possibilities, to_add=""):
-    """
+    r"""
     Helper function for regex manipulation:
     Construct a regex representing "any of" the given possibilities
     :param possibilities: list of strings representing different word possibilities
     :param to_add: string to add at the beginning of each possibility (optional)
     :return: string corresponding to regex which represents any of the given possibilities
-    """
+    r"""
     assert len(possibilities) > 0
-    s = "(?:"
+    s = r"(?:"
     if len(to_add) > 0:
-        s += possibilities[0] + to_add + " "
+        s += possibilities[0] + to_add + r" "
     else:
         s += possibilities[0]
     for i in range(len(possibilities) - 1):
         if len(to_add) > 0:
-            s += "|" + possibilities[i + 1] + to_add + " "
+            s += r"|" + possibilities[i + 1] + to_add + r" "
         else:
-            s += "|" + possibilities[i + 1]
-    return s + ")"
+            s += r"|" + possibilities[i + 1]
+    return s + r")"
 
 
 ########################################################################################################################
 # Regex manipulation: helper variables
 ########################################################################################################################
 # Identifiers
-global_id = r'(?<!%")@["\w\d\.\-\_\$\\]+'
-local_id_no_perc = '["\@\d\w\.\-\_\:]+'
-local_id = "%" + local_id_no_perc
+global_id = r'(?<!%")@[r"\w\d\.\-\_\$\\]+'
+local_id_no_perc = r'[r"\@\d\w\.\-\_\:]+'
+local_id = r"%" + local_id_no_perc
 local_or_global_id = r"(" + global_id + r"|" + local_id + r")"
 
 # Options and linkages
 linkage = any_of(
     [
-        " private",
-        " external",
-        " internal",
-        " linkonce_odr",
-        " appending",
-        " external",
-        " internal",
-        " unnamed_addr",
-        " common",
-        " hidden",
-        " weak",
-        " linkonce",
-        " extern_weak",
-        " weak_odr",
-        " private",
-        " available_externally",
-        " local_unnamed_addr",
-        " thread_local",
-        " linker_private",
+        r" private",
+        r" external",
+        r" internal",
+        r" linkonce_odr",
+        r" appending",
+        r" external",
+        r" internal",
+        r" unnamed_addr",
+        r" common",
+        r" hidden",
+        r" weak",
+        r" linkonce",
+        r" extern_weak",
+        r" weak_odr",
+        r" private",
+        r" available_externally",
+        r" local_unnamed_addr",
+        r" thread_local",
+        r" linker_private",
     ]
 )
 
@@ -95,35 +95,35 @@ def any_of(possibilities, to_add=""):
 immediate_value_float_sci = r"(?<!\w)[-]?[0-9]+\.[0-9]+(?:e\+?-?[0-9]+)?"
 immediate_value_float_hexa = r"(?<!\w)[-]?0[xX][hklmHKLM]?[A-Fa-f0-9]+"
 immediate_value_float = (
-    r"(?:" + immediate_value_float_sci + "|" + immediate_value_float_hexa + ")"
+    r"(?:" + immediate_value_float_sci + r"|" + immediate_value_float_hexa + r")"
 )
 immediate_value_vector_bool = (
     r"<i1 "
     + immediate_value_bool
     + r"(?:, i1 (?:"
     + immediate_value_bool
-    + "|undef))*>"
+    + r"|undef))*>"
 )
 immediate_value_vector_int = (
-    r"<i\d+ "
+    r"<i\d+ r"
     + immediate_value_int
     + r"(?:, i\d+ (?:"
     + immediate_value_int
-    + "|undef))*>"
+    + r"|undef))*>"
 )
 immediate_value_vector_float = (
     r"<float "
     + immediate_value_float
     + r"(?:, float (?:"
     + immediate_value_float
-    + "|undef))*>"
+    + r"|undef))*>"
 )
 immediate_value_vector_double = (
     r"<double "
     + immediate_value_float
     + r"(?:, double (?:"
     + immediate_value_float
-    + "|undef))*>"
+    + r"|undef))*>"
 )
 immediate_value_string = r'(?<!\w)c".+"'
 immediate_value_misc = r"(?:null|zeroinitializer)"
@@ -187,9 +187,9 @@ def any_of(possibilities, to_add=""):
 # Names of aggregate types
 # Lookahead so that names like '%struct.attribute_group**' won't be matched as just %struct.attribute
 struct_lookahead = r"(?=[\s,\*\]\}])"
-struct_name_add_on = '(?:\([\w\d=]+\)")?'
+struct_name_add_on = r'(?:\([\w\d=]+\)")?'
 struct_name_without_lookahead = (
-    '%["\@\d\w\.\-\_:]+(?:(?:<["\@\d\w\.\-\_:,<>\(\) \*]+>|\(["\@\d\w\.\-\_:,<> \*]+\)|\w+)?::[" \@\d\w\.\-\_:\)\(]*)*'
+    r'%[r"\@\d\w\.\-\_:]+(?:(?:<[r"\@\d\w\.\-\_:,<>\(\) \*]+>|\([r"\@\d\w\.\-\_:,<> \*]+\)|\w+)?::[r" \@\d\w\.\-\_:\)\(]*)*'
     + struct_name_add_on
 )
 struct_name = struct_name_without_lookahead + struct_lookahead
@@ -207,32 +207,32 @@ def any_of(possibilities, to_add=""):
 # Types
 base_type = r"(?:i\d+|double|float|opaque)\**"
 first_class_types = [
-    "i\d+",
-    "half",
-    "float",
-    "double",
-    "fp_128",
-    "x86_fp80",
-    "ppc_fp128",
-    "<%ID>",
+    r"i\d+",
+    r"half",
+    r"float",
+    r"double",
+    r"fp_128",
+    r"x86_fp80",
+    r"ppc_fp128",
+    r"<%ID>",
 ]
-first_class_type = any_of(first_class_types) + "\**"
+first_class_type = any_of(first_class_types) + r"\**"
 base_type_or_struct_name = any_of([base_type, struct_name_without_lookahead])
 ptr_to_base_type = base_type + r"\*+"
 vector_type = r"<\d+ x " + base_type + r">"
 ptr_to_vector_type = vector_type + r"\*+"
 array_type = r"\[\d+ x " + base_type + r"\]"
 ptr_to_array_type = array_type + r"\*+"
-array_of_array_type = "\[\d+ x " + "\[\d+ x " + base_type + "\]" + "\]"
+array_of_array_type = r"\[\d+ x " + r"\[\d+ x " + base_type + r"\]" + r"\]"
 struct = struct_name_without_lookahead
 ptr_to_struct = struct + r"\*+"
 function_type = (
     base_type
-    + " \("
+    + r" \("
     + any_of([base_type, vector_type, array_type, "..."], ",")
-    + "*"
+    + r"*"
     + any_of([base_type, vector_type, array_type, "..."])
-    + "\)\**"
+    + r"\)\**"
 )
 any_type = any_of(
     [
@@ -269,586 +269,586 @@ def any_of(possibilities, to_add=""):
     [base_type, vector_type, array_type, array_of_array_type, function_type], ","
 )
 literal_structure = (
-    "(<?{ " + structure_entry_with_comma + "*" + structure_entry + " }>?|{})"
+    r"(<?{ " + structure_entry_with_comma + r"*" + structure_entry + r" }>?|{})"
 )
 
 # Tokens
-unknown_token = "!UNK"  # starts with '!' to guarantee it will appear first in the alphabetically sorted vocabulary
+unknown_token = r"!UNK"  # starts with '!' to guarantee it will appear first in the alphabetically sorted vocabulary
 
 ########################################################################################################################
 # Tags for clustering statements (by statement semantics) and helper functions
 ########################################################################################################################
 # List of families of operations
 llvm_IR_stmt_families = [
-    # ["tag level 1",                  "tag level 2",            "tag level 3",              "regex"                    ]
-    ["unknown token", "unknown token", "unknown token", "!UNK"],
-    ["integer arithmetic", "addition", "add integers", "<%ID> = add .*"],
-    ["integer arithmetic", "subtraction", "subtract integers", "<%ID> = sub .*"],
+    # [r"tag level 1",                  r"tag level 2",            r"tag level 3",              r"regex"                    ]
+    [r"unknown token", "unknown token", "unknown token", "!UNK"],
+    [r"integer arithmetic", "addition", "add integers", "<%ID> = add .*"],
+    [r"integer arithmetic", "subtraction", "subtract integers", "<%ID> = sub .*"],
     [
-        "integer arithmetic",
-        "multiplication",
-        "multiply integers",
-        "<%ID> = mul .*",
+        r"integer arithmetic",
+        r"multiplication",
+        r"multiply integers",
+        r"<%ID> = mul .*",
     ],
     [
-        "integer arithmetic",
-        "division",
-        "unsigned integer division",
-        "<%ID> = udiv .*",
+        r"integer arithmetic",
+        r"division",
+        r"unsigned integer division",
+        r"<%ID> = udiv .*",
     ],
     [
-        "integer arithmetic",
-        "division",
-        "signed integer division",
-        "<%ID> = sdiv .*",
+        r"integer arithmetic",
+        r"division",
+        r"signed integer division",
+        r"<%ID> = sdiv .*",
     ],
     [
-        "integer arithmetic",
-        "remainder",
-        "remainder of signed div",
-        "<%ID> = srem .*",
+        r"integer arithmetic",
+        r"remainder",
+        r"remainder of signed div",
+        r"<%ID> = srem .*",
     ],
     [
-        "integer arithmetic",
-        "remainder",
-        "remainder of unsigned div.",
-        "<%ID> = urem .*",
+        r"integer arithmetic",
+        r"remainder",
+        r"remainder of unsigned div.",
+        r"<%ID> = urem .*",
     ],
-    ["floating-point arithmetic", "addition", "add floats", "<%ID> = fadd .*"],
+    [r"floating-point arithmetic", "addition", "add floats", "<%ID> = fadd .*"],
     [
-        "floating-point arithmetic",
-        "subtraction",
-        "subtract floats",
-        "<%ID> = fsub .*",
+        r"floating-point arithmetic",
+        r"subtraction",
+        r"subtract floats",
+        r"<%ID> = fsub .*",
     ],
     [
-        "floating-point arithmetic",
-        "multiplication",
-        "multiply floats",
-        "<%ID> = fmul .*",
+        r"floating-point arithmetic",
+        r"multiplication",
+        r"multiply floats",
+        r"<%ID> = fmul .*",
     ],
-    ["floating-point arithmetic", "division", "divide floats", "<%ID> = fdiv .*"],
-    ["bitwise arithmetic", "and", "and", "<%ID> = and .*"],
-    ["bitwise arithmetic", "or", "or", "<%ID> = or .*"],
-    ["bitwise arithmetic", "xor", "xor", "<%ID> = xor .*"],
-    ["bitwise arithmetic", "shift left", "shift left", "<%ID> = shl .*"],
-    ["bitwise arithmetic", "arithmetic shift right", "ashr", "<%ID> = ashr .*"],
+    [r"floating-point arithmetic", "division", "divide floats", "<%ID> = fdiv .*"],
+    [r"bitwise arithmetic", "and", "and", "<%ID> = and .*"],
+    [r"bitwise arithmetic", "or", "or", "<%ID> = or .*"],
+    [r"bitwise arithmetic", "xor", "xor", "<%ID> = xor .*"],
+    [r"bitwise arithmetic", "shift left", "shift left", "<%ID> = shl .*"],
+    [r"bitwise arithmetic", "arithmetic shift right", "ashr", "<%ID> = ashr .*"],
     [
-        "bitwise arithmetic",
-        "logical shift right",
-        "logical shift right",
-        "<%ID> = lshr .*",
+        r"bitwise arithmetic",
+        r"logical shift right",
+        r"logical shift right",
+        r"<%ID> = lshr .*",
     ],
     [
-        "comparison operation",
-        "compare integers",
-        "compare integers",
-        "<%ID> = icmp .*",
+        r"comparison operation",
+        r"compare integers",
+        r"compare integers",
+        r"<%ID> = icmp .*",
     ],
     [
-        "comparison operation",
-        "compare floats",
-        "compare floats",
-        "<%ID> = fcmp .*",
+        r"comparison operation",
+        r"compare floats",
+        r"compare floats",
+        r"<%ID> = fcmp .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast single val",
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque) .* to .*",
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast single val",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque) .* to .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast single val*",
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\* .* to .*",
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast single val*",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\* .* to .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast single val**",
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\* .* to .*",
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast single val**",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\* .* to .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast single val***",
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\*\* .* to .*",
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast single val***",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\*\* .* to .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast single val****",
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\*\*\* .* to .*",
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast single val****",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\*\*\* .* to .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast array",
-        "<%ID> = bitcast \[\d.* to .*",
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast array",
+        r"<%ID> = bitcast \[\d.* to .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast vector",
-        "<%ID> = bitcast <\d.* to .*",
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast vector",
+        r"<%ID> = bitcast <\d.* to .*",
     ],
     [
-        "conversion operation",
-        "bitcast",
-        "bitcast structure",
-        '<%ID> = bitcast (%"|<{|<%|{).* to .*',
+        r"conversion operation",
+        r"bitcast",
+        r"bitcast structure",
+        r'<%ID> = bitcast (%"|<{|<%|{).* to .*',
     ],
-    ["conversion operation", "bitcast", "bitcast void", "<%ID> = bitcast void "],
+    [r"conversion operation", "bitcast", "bitcast void", "<%ID> = bitcast void "],
     [
-        "conversion operation",
-        "extension/truncation",
-        "extend float",
-        "<%ID> = fpext .*",
+        r"conversion operation",
+        r"extension/truncation",
+        r"extend float",
+        r"<%ID> = fpext .*",
     ],
     [
-        "conversion operation",
-        "extension/truncation",
-        "truncate floats",
-        "<%ID> = fptrunc .*",
+        r"conversion operation",
+        r"extension/truncation",
+        r"truncate floats",
+        r"<%ID> = fptrunc .*",
     ],
     [
-        "conversion operation",
-        "extension/truncation",
-        "sign extend ints",
-        "<%ID> = sext .*",
+        r"conversion operation",
+        r"extension/truncation",
+        r"sign extend ints",
+        r"<%ID> = sext .*",
     ],
     [
-        "conversion operation",
-        "extension/truncation",
-        "truncate int to ... ",
-        "<%ID> = trunc .* to .*",
+        r"conversion operation",
+        r"extension/truncation",
+        r"truncate int to ... ",
+        r"<%ID> = trunc .* to .*",
     ],
     [
-        "conversion operation",
-        "extension/truncation",
-        "zero extend integers",
-        "<%ID> = zext .*",
+        r"conversion operation",
+        r"extension/truncation",
+        r"zero extend integers",
+        r"<%ID> = zext .*",
     ],
     [
-        "conversion operation",
-        "convert",
-        "convert signed integers to... ",
-        "<%ID> = sitofp .*",
+        r"conversion operation",
+        r"convert",
+        r"convert signed integers to... ",
+        r"<%ID> = sitofp .*",
     ],
     [
-        "conversion operation",
-        "convert",
-        "convert unsigned integer to... ",
-        "<%ID> = uitofp .*",
+        r"conversion operation",
+        r"convert",
+        r"convert unsigned integer to... ",
+        r"<%ID> = uitofp .*",
     ],
     [
-        "conversion operation",
-        "convert int to ptr",
-        "convert int to ptr",
-        "<%ID> = inttoptr .*",
+        r"conversion operation",
+        r"convert int to ptr",
+        r"convert int to ptr",
+        r"<%ID> = inttoptr .*",
     ],
     [
-        "conversion operation",
-        "convert ptr to int",
-        "convert ptr to int",
-        "<%ID> = ptrtoint .*",
+        r"conversion operation",
+        r"convert ptr to int",
+        r"convert ptr to int",
+        r"<%ID> = ptrtoint .*",
     ],
     [
-        "conversion operation",
-        "convert floats",
-        "convert float to sint",
-        "<%ID> = fptosi .*",
+        r"conversion operation",
+        r"convert floats",
+        r"convert float to sint",
+        r"<%ID> = fptosi .*",
     ],
     [
-        "conversion operation",
-        "convert floats",
-        "convert float to uint",
-        "<%ID> = fptoui .*",
+        r"conversion operation",
+        r"convert floats",
+        r"convert float to uint",
+        r"<%ID> = fptoui .*",
     ],
-    ["control flow", "phi", "phi", "<%ID> = phi .*"],
+    [r"control flow", "phi", "phi", "<%ID> = phi .*"],
     [
-        "control flow",
-        "switch",
-        "jump table line",
-        "i\d{1,2} <(INT|FLOAT)>, label <%ID>",
+        r"control flow",
+        r"switch",
+        r"jump table line",
+        r"i\d{1,2} <(INT|FLOAT)>, label <%ID>",
     ],
-    ["control flow", "select", "select", "<%ID> = select .*"],
-    ["control flow", "invoke", "invoke and ret type", "<%ID> = invoke .*"],
-    ["control flow", "invoke", "invoke void", "invoke (fastcc )?void .*"],
-    ["control flow", "branch", "branch conditional", "br i1 .*"],
-    ["control flow", "branch", "branch unconditional", "br label .*"],
-    ["control flow", "branch", "branch indirect", "indirectbr .*"],
-    ["control flow", "control flow", "switch", "switch .*"],
-    ["control flow", "return", "return", "ret .*"],
-    ["control flow", "resume", "resume", "resume .*"],
-    ["control flow", "unreachable", "unreachable", "unreachable.*"],
-    ["control flow", "exception handling", "catch block", "catch .*"],
-    ["control flow", "exception handling", "cleanup clause", "cleanup"],
+    [r"control flow", "select", "select", "<%ID> = select .*"],
+    [r"control flow", "invoke", "invoke and ret type", "<%ID> = invoke .*"],
+    [r"control flow", "invoke", "invoke void", "invoke (fastcc )?void .*"],
+    [r"control flow", "branch", "branch conditional", "br i1 .*"],
+    [r"control flow", "branch", "branch unconditional", "br label .*"],
+    [r"control flow", "branch", "branch indirect", "indirectbr .*"],
+    [r"control flow", "control flow", "switch", "switch .*"],
+    [r"control flow", "return", "return", "ret .*"],
+    [r"control flow", "resume", "resume", "resume .*"],
+    [r"control flow", "unreachable", "unreachable", "unreachable.*"],
+    [r"control flow", "exception handling", "catch block", "catch .*"],
+    [r"control flow", "exception handling", "cleanup clause", "cleanup"],
     [
-        "control flow",
-        "exception handling",
-        "landingpad for exceptions",
-        "<%ID> = landingpad .",
+        r"control flow",
+        r"exception handling",
+        r"landingpad for exceptions",
+        r"<%ID> = landingpad .",
     ],
     [
-        "function",
-        "function call",
-        "sqrt (llvm-intrinsic)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>) @(llvm|llvm\..*)\.sqrt.*",
+        r"function",
+        r"function call",
+        r"sqrt (llvm-intrinsic)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>) @(llvm|llvm\..*)\.sqrt.*",
     ],
     [
-        "function",
-        "function call",
-        "fabs (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.fabs.*",
+        r"function",
+        r"function call",
+        r"fabs (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.fabs.*",
     ],
     [
-        "function",
-        "function call",
-        "max (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.max.*",
+        r"function",
+        r"function call",
+        r"max (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.max.*",
     ],
     [
-        "function",
-        "function call",
-        "min (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.min.*",
+        r"function",
+        r"function call",
+        r"min (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.min.*",
     ],
     [
-        "function",
-        "function call",
-        "fma (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.fma.*",
+        r"function",
+        r"function call",
+        r"fma (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.fma.*",
     ],
     [
-        "function",
-        "function call",
-        "phadd (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.phadd.*",
+        r"function",
+        r"function call",
+        r"phadd (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.phadd.*",
     ],
     [
-        "function",
-        "function call",
-        "pabs (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.pabs.*",
+        r"function",
+        r"function call",
+        r"pabs (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.pabs.*",
     ],
     [
-        "function",
-        "function call",
-        "pmulu (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.pmulu.*",
+        r"function",
+        r"function call",
+        r"pmulu (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call (fast |)?(i\d+|float|double|x86_fp80|<%ID>|<\d x float>|<\d x double>|<\d x i\d+>) @(llvm|llvm\..*)\.pmulu.*",
     ],
     [
-        "function",
-        "function call",
-        "umul (llvm-intr.)",
-        "<%ID> = (tail |musttail |notail )?call {.*} @llvm\.umul.*",
+        r"function",
+        r"function call",
+        r"umul (llvm-intr.)",
+        r"<%ID> = (tail |musttail |notail )?call {.*} @llvm\.umul.*",
     ],
     [
-        "function",
-        "function call",
-        "prefetch (llvm-intr.)",
-        "(tail |musttail |notail )?call void @llvm\.prefetch.*",
+        r"function",
+        r"function call",
+        r"prefetch (llvm-intr.)",
+        r"(tail |musttail |notail )?call void @llvm\.prefetch.*",
     ],
     [
-        "function",
-        "function call",
-        "trap (llvm-intr.)",
-        "(tail |musttail |notail )?call void @llvm\.trap.*",
+        r"function",
+        r"function call",
+        r"trap (llvm-intr.)",
+        r"(tail |musttail |notail )?call void @llvm\.trap.*",
     ],
-    ["function", "func decl / def", "function declaration", "declare .*"],
-    ["function", "func decl / def", "function definition", "define .*"],
+    [r"function", "func decl / def", "function declaration", "declare .*"],
+    [r"function", "func decl / def", "function definition", "define .*"],
     [
-        "function",
-        "function call",
-        "function call void",
-        "(tail |musttail |notail )?call( \w+)? void [\w\)\(\}\{\.\,\*\d\[\]\s<>%]*(<[@%]ID>\(|.*bitcast )",
+        r"function",
+        r"function call",
+        r"function call void",
+        r"(tail |musttail |notail )?call( \w+)? void [\w\)\(\}\{\.\,\*\d\[\]\s<>%]*(<[@%]ID>\(|.*bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call mem lifetime",
-        "(tail |musttail |notail )?call( \w+)? void ([\w)(\.\,\*\d ])*@llvm\.lifetime.*",
+        r"function",
+        r"function call",
+        r"function call mem lifetime",
+        r"(tail |musttail |notail )?call( \w+)? void ([\w)(\.\,\*\d ])*@llvm\.lifetime.*",
     ],
     [
-        "function",
-        "function call",
-        "function call mem copy",
-        "(tail |musttail |notail )?call( \w+)? void ([\w)(\.\,\*\d ])*@llvm\.memcpy\..*",
+        r"function",
+        r"function call",
+        r"function call mem copy",
+        r"(tail |musttail |notail )?call( \w+)? void ([\w)(\.\,\*\d ])*@llvm\.memcpy\..*",
     ],
     [
-        "function",
-        "function call",
-        "function call mem set",
-        "(tail |musttail |notail )?call( \w+)? void ([\w)(\.\,\*\d ])*@llvm\.memset\..*",
+        r"function",
+        r"function call",
+        r"function call mem set",
+        r"(tail |musttail |notail )?call( \w+)? void ([\w)(\.\,\*\d ])*@llvm\.memset\..*",
     ],
     [
-        "function",
-        "function call",
-        "function call single val",
-        "<%ID> = (tail |musttail |notail )?call[^{]* (i\d+|float|double|x86_fp80|<\d+ x (i\d+|float|double)>) (.*<[@%]ID>\(|(\(.*\) )?bitcast ).*",
+        r"function",
+        r"function call",
+        r"function call single val",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* (i\d+|float|double|x86_fp80|<\d+ x (i\d+|float|double)>) (.*<[@%]ID>\(|(\(.*\) )?bitcast ).*",
     ],
     [
-        "function",
-        "function call",
-        "function call single val*",
-        "<%ID> = (tail |musttail |notail )?call[^{]* (i\d+|float|double|x86_fp80)\* (.*<[@%]ID>\(|\(.*\) bitcast ).*",
+        r"function",
+        r"function call",
+        r"function call single val*",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* (i\d+|float|double|x86_fp80)\* (.*<[@%]ID>\(|\(.*\) bitcast ).*",
     ],
     [
-        "function",
-        "function call",
-        "function call single val**",
-        "<%ID> = (tail |musttail |notail )?call[^{]* (i\d+|float|double|x86_fp80)\*\* (.*<[@%]ID>\(|\(.*\) bitcast ).*",
+        r"function",
+        r"function call",
+        r"function call single val**",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* (i\d+|float|double|x86_fp80)\*\* (.*<[@%]ID>\(|\(.*\) bitcast ).*",
     ],
     [
-        "function",
-        "function call",
-        "function call array",
-        "<%ID> = (tail |musttail |notail )?call[^{]* \[.*\] (\(.*\) )?(<[@%]ID>\(|\(.*\) bitcast )",
+        r"function",
+        r"function call",
+        r"function call array",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* \[.*\] (\(.*\) )?(<[@%]ID>\(|\(.*\) bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call array*",
-        "<%ID> = (tail |musttail |notail )?call[^{]* \[.*\]\* (\(.*\) )?(<[@%]ID>\(|\(.*\) bitcast )",
+        r"function",
+        r"function call",
+        r"function call array*",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* \[.*\]\* (\(.*\) )?(<[@%]ID>\(|\(.*\) bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call array**",
-        "<%ID> = (tail |musttail |notail )?call[^{]* \[.*\]\*\* (\(.*\) )?(<[@%]ID>\(|\(.*\) bitcast )",
+        r"function",
+        r"function call",
+        r"function call array**",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* \[.*\]\*\* (\(.*\) )?(<[@%]ID>\(|\(.*\) bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call structure",
-        "<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>) (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
+        r"function",
+        r"function call",
+        r"function call structure",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>) (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call structure*",
-        "<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>)\* (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
+        r"function",
+        r"function call",
+        r"function call structure*",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>)\* (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call structure**",
-        "<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>)\*\* (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
+        r"function",
+        r"function call",
+        r"function call structure**",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>)\*\* (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call structure***",
-        "<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>)\*\*\* (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
+        r"function",
+        r"function call",
+        r"function call structure***",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* (\{ .* \}[\w\_]*|<?\{ .* \}>?|opaque|\{\}|<%ID>)\*\*\* (\(.*\)\*? )?(<[@%]ID>\(|\(.*\) bitcast )",
     ],
     [
-        "function",
-        "function call",
-        "function call asm value",
-        "<%ID> = (tail |musttail |notail )?call.* asm .*",
+        r"function",
+        r"function call",
+        r"function call asm value",
+        r"<%ID> = (tail |musttail |notail )?call.* asm .*",
     ],
     [
-        "function",
-        "function call",
-        "function call asm void",
-        "(tail |musttail |notail )?call void asm .*",
+        r"function",
+        r"function call",
+        r"function call asm void",
+        r"(tail |musttail |notail )?call void asm .*",
     ],
     [
-        "function",
-        "function call",
-        "function call function",
-        "<%ID> = (tail |musttail |notail )?call[^{]* void \([^\(\)]*\)\** <[@%]ID>\(",
+        r"function",
+        r"function call",
+        r"function call function",
+        r"<%ID> = (tail |musttail |notail )?call[^{]* void \([^\(\)]*\)\** <[@%]ID>\(",
     ],
     [
-        "global variables",
-        "glob. var. definition",
-        "???",
-        "<@ID> = (?!.*constant)(?!.*alias).*",
+        r"global variables",
+        r"glob. var. definition",
+        r"???",
+        r"<@ID> = (?!.*constant)(?!.*alias).*",
     ],
-    ["global variables", "constant definition", "???", "<@ID> = .*constant .*"],
+    [r"global variables", "constant definition", "???", "<@ID> = .*constant .*"],
     [
-        "memory access",
-        "load from memory",
-        "load structure",
-        '<%ID> = load (\w* )?(%"|<\{|\{ <|\{ \[|\{ |<%|opaque).*',
+        r"memory access",
+        r"load from memory",
+        r"load structure",
+        r'<%ID> = load (\w* )?(%"|<\{|\{ <|\{ \[|\{ |<%|opaque).*',
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val*",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val*",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val**",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val**",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val***",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val***",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val****",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val****",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val*****",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*\*[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val*****",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*\*[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val******",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*\*\*[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val******",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*\*\*[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load single val*******",
-        "<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*\*\*\*[, ].*",
+        r"memory access",
+        r"load from memory",
+        r"load single val*******",
+        r"<%ID> = load (\w* )?(i\d+|float|double|x86_fp80)\*\*\*\*\*\*\*[, ].*",
     ],
     [
-        "memory access",
-        "load from memory",
-        "load vector",
-        "<%ID> = load <\d+ x .*",
+        r"memory access",
+        r"load from memory",
+        r"load vector",
+        r"<%ID> = load <\d+ x .*",
     ],
-    ["memory access", "load from memory", "load array", "<%ID> = load \[\d.*"],
+    ["memory access", "load from memory", "load array", r"<%ID> = load \[\d.*"],
     [
-        "memory access",
-        "load from memory",
-        "load fction ptr",
-        "<%ID> = load void \(",
+        r"memory access",
+        r"load from memory",
+        r"load fction ptr",
+        r"<%ID> = load void \(",
     ],
-    ["memory access", "store", "store", "store.*"],
-    ["memory addressing", "GEP", "GEP", "<%ID> = getelementptr .*"],
+    [r"memory access", "store", "store", "store.*"],
+    [r"memory addressing", "GEP", "GEP", r"<%ID> = getelementptr .*"],
     [
-        "memory allocation",
-        "allocate on stack",
-        "allocate structure",
-        '<%ID> = alloca (%"|<{|<%|{ |opaque).*',
+        r"memory allocation",
+        r"allocate on stack",
+        r"allocate structure",
+        r'<%ID> = alloca (%"|<{|<%|{ |opaque).*',
     ],
     [
-        "memory allocation",
-        "allocate on stack",
-        "allocate vector",
-        "<%ID> = alloca <\d.*",
+        r"memory allocation",
+        r"allocate on stack",
+        r"allocate vector",
+        r"<%ID> = alloca <\d.*",
     ],
     [
-        "memory allocation",
-        "allocate on stack",
-        "allocate array",
-        "<%ID> = alloca \[\d.*",
+        r"memory allocation",
+        r"allocate on stack",
+        r"allocate array",
+        r"<%ID> = alloca \[\d.*",
     ],
     [
-        "memory allocation",
-        "allocate on stack",
-        "allocate single value",
-        "<%ID> = alloca (double|float|i\d{1,3})\*?.*",
+        r"memory allocation",
+        r"allocate on stack",
+        r"allocate single value",
+        r"<%ID> = alloca (double|float|i\d{1,3})\*?.*",
     ],
     [
-        "memory allocation",
-        "allocate on stack",
-        "allocate void",
-        "<%ID> = alloca void \(.*",
+        r"memory allocation",
+        r"allocate on stack",
+        r"allocate void",
+        r"<%ID> = alloca void \(.*",
     ],
     [
-        "memory atomics",
-        "atomic memory modify",
-        "atomicrw xchg",
-        "<%ID> = atomicrmw.* xchg .*",
+        r"memory atomics",
+        r"atomic memory modify",
+        r"atomicrw xchg",
+        r"<%ID> = atomicrmw.* xchg .*",
     ],
     [
-        "memory atomics",
-        "atomic memory modify",
-        "atomicrw add",
-        "<%ID> = atomicrmw.* add .*",
+        r"memory atomics",
+        r"atomic memory modify",
+        r"atomicrw add",
+        r"<%ID> = atomicrmw.* add .*",
     ],
     [
-        "memory atomics",
-        "atomic memory modify",
-        "atomicrw sub",
-        "<%ID> = atomicrmw.* sub .*",
+        r"memory atomics",
+        r"atomic memory modify",
+        r"atomicrw sub",
+        r"<%ID> = atomicrmw.* sub .*",
     ],
     [
-        "memory atomics",
-        "atomic memory modify",
-        "atomicrw or",
-        "<%ID> = atomicrmw.* or .*",
+        r"memory atomics",
+        r"atomic memory modify",
+        r"atomicrw or",
+        r"<%ID> = atomicrmw.* or .*",
     ],
     [
-        "memory atomics",
-        "atomic compare exchange",
-        "cmpxchg single val",
-        "<%ID> = cmpxchg (weak )?(i\d+|float|double|x86_fp80)\*",
+        r"memory atomics",
+        r"atomic compare exchange",
+        r"cmpxchg single val",
+        r"<%ID> = cmpxchg (weak )?(i\d+|float|double|x86_fp80)\*",
     ],
     [
-        "non-instruction",
-        "label",
-        "label declaration",
-        "; <label>:.*(\s+; preds = <LABEL>)?",
+        r"non-instruction",
+        r"label",
+        r"label declaration",
+        r"; <label>:.*(\s+; preds = <LABEL>)?",
     ],
     [
-        "non-instruction",
-        "label",
-        "label declaration",
-        "<LABEL>:( ; preds = <LABEL>)?",
+        r"non-instruction",
+        r"label",
+        r"label declaration",
+        r"<LABEL>:( ; preds = <LABEL>)?",
     ],
     [
-        "value aggregation",
-        "extract value",
-        "extract value",
-        "<%ID> = extractvalue .*",
+        r"value aggregation",
+        r"extract value",
+        r"extract value",
+        r"<%ID> = extractvalue .*",
     ],
     [
-        "value aggregation",
-        "insert value",
-        "insert value",
-        "<%ID> = insertvalue .*",
+        r"value aggregation",
+        r"insert value",
+        r"insert value",
+        r"<%ID> = insertvalue .*",
     ],
     [
-        "vector operation",
-        "insert element",
-        "insert element",
-        "<%ID> = insertelement .*",
+        r"vector operation",
+        r"insert element",
+        r"insert element",
+        r"<%ID> = insertelement .*",
     ],
     [
-        "vector operation",
-        "extract element",
-        "extract element",
-        "<%ID> = extractelement .*",
+        r"vector operation",
+        r"extract element",
+        r"extract element",
+        r"<%ID> = extractelement .*",
     ],
     [
-        "vector operation",
-        "shuffle vector",
-        "shuffle vector",
-        "<%ID> = shufflevector .*",
+        r"vector operation",
+        r"shuffle vector",
+        r"shuffle vector",
+        r"<%ID> = shufflevector .*",
     ],
 ]
 
 
 # Helper functions for exploring llvm_IR_families
 def get_list_tag_level_1():
-    """
+    r"""
     Get the list of all level-1 tags in the data structure llvm_IR_families
 
     :return: list containing strings corresponding to all level 1 tags
-    """
+    r"""
     list_tags = list()
     for fam in llvm_IR_stmt_families:
         list_tags.append(fam[0])
@@ -857,23 +857,23 @@ def get_list_tag_level_1():
 
 
 def get_list_tag_level_2(tag_level_1="all"):
-    """
+    r"""
     Get the list of all level-2 tags in the data structure llvm_IR_families
     corresponding to the string given as an input, or absolutely all of them
-    if input == 'all'
+    if input == r'all'
 
     :param tag_level_1: string containing the level-1 tag to query, or 'all'
     :return: list of strings
-    """
+    r"""
 
     # Make sure the input parameter is valid
-    assert tag_level_1 in get_list_tag_level_1() or tag_level_1 == "all", (
-        tag_level_1 + " invalid"
+    assert tag_level_1 in get_list_tag_level_1() or tag_level_1 == r"all", (
+        tag_level_1 + r" invalid"
     )
 
     list_tags = list()
 
-    if tag_level_1 == "all":
+    if tag_level_1 == r"all":
         for fam in llvm_IR_stmt_families:
             list_tags.append(fam[1])
         list_tags = sorted(set(list_tags))
@@ -889,5189 +889,5203 @@ def get_list_tag_level_2(tag_level_1="all"):
 # Tags for clustering statements (by statement type)
 ########################################################################################################################
 # Helper lists
-types_int = ["i1", "i8", "i16", "i32", "i64"]
-types_flpt = ["half", "float", "double", "fp128", "x86_fp80", "ppc_fp128"]
+types_int = [r"i1", "i8", "i16", "i32", "i64"]
+types_flpt = [r"half", "float", "double", "fp128", "x86_fp80", "ppc_fp128"]
 fast_math_flag = [
-    "",
-    "nnan ",
-    "ninf ",
-    "nsz ",
-    "arcp ",
-    "contract ",
-    "afn ",
-    "reassoc ",
-    "fast ",
+    r"",
+    r"nnan ",
+    r"ninf ",
+    r"nsz ",
+    r"arcp ",
+    r"contract ",
+    r"afn ",
+    r"reassoc ",
+    r"fast ",
 ]
-opt_load = ["atomic ", "volatile "]
-opt_addsubmul = ["nsw ", "nuw ", "nuw nsw "]
-opt_usdiv = ["", "exact "]
+opt_load = [r"atomic ", "volatile "]
+opt_addsubmul = [r"nsw ", "nuw ", "nuw nsw "]
+opt_usdiv = [r"", "exact "]
 opt_icmp = [
-    "eq ",
-    "ne ",
-    "ugt ",
-    "uge ",
-    "ult ",
-    "ule ",
-    "sgt ",
-    "sge ",
-    "slt ",
-    "sle ",
+    r"eq ",
+    r"ne ",
+    r"ugt ",
+    r"uge ",
+    r"ult ",
+    r"ule ",
+    r"sgt ",
+    r"sge ",
+    r"slt ",
+    r"sle ",
 ]
 opt_fcmp = [
-    "false ",
-    "oeq ",
-    "ogt ",
-    "oge ",
-    "olt ",
-    "olt ",
-    "ole ",
-    "one ",
-    "ord ",
-    "ueq ",
-    "ugt ",
-    "uge ",
-    "ult ",
-    "ule ",
-    "une ",
-    "uno ",
-    "true ",
+    r"false ",
+    r"oeq ",
+    r"ogt ",
+    r"oge ",
+    r"olt ",
+    r"olt ",
+    r"ole ",
+    r"one ",
+    r"ord ",
+    r"ueq ",
+    r"ugt ",
+    r"uge ",
+    r"ult ",
+    r"ule ",
+    r"une ",
+    r"uno ",
+    r"true ",
 ]
 opt_define = [
-    "",
-    "linkonce_odr ",
-    "linkonce_odr ",
-    "zeroext ",
-    "dereferenceable\(\d+\) ",
-    "hidden ",
-    "internal ",
-    "nonnull ",
-    "weak_odr ",
-    "fastcc ",
-    "noalias ",
-    "signext ",
-    "spir_kernel ",
+    r"",
+    r"linkonce_odr ",
+    r"linkonce_odr ",
+    r"zeroext ",
+    r"dereferenceable\(\d+\) ",
+    r"hidden ",
+    r"internal ",
+    r"nonnull ",
+    r"weak_odr ",
+    r"fastcc ",
+    r"noalias ",
+    r"signext ",
+    r"spir_kernel ",
 ]
 opt_invoke = [
-    "",
-    "dereferenceable\(\d+\) ",
-    "noalias ",
-    "fast ",
-    "zeroext ",
-    "signext ",
-    "fastcc ",
+    r"",
+    r"dereferenceable\(\d+\) ",
+    r"noalias ",
+    r"fast ",
+    r"zeroext ",
+    r"signext ",
+    r"fastcc ",
 ]
-opt_GEP = ["", "inbounds "]
+opt_GEP = [r"", "inbounds "]
 
 
 # Helper functions
 def any_of(possibilities, to_add=""):
-    """
+    r"""
     Construct a regex representing "any of" the given possibilities
     :param possibilities: list of strings representing different word possibilities
     :param to_add: string to add at the beginning of each possibility (optional)
     :return: string corresponding to regex which represents any of the given possibilities
-    """
+    r"""
     assert len(possibilities) > 0
-    s = "("
+    s = r"("
     if len(to_add) > 0:
-        s += possibilities[0] + to_add + " "
+        s += possibilities[0] + to_add + r" "
     else:
         s += possibilities[0]
     for i in range(len(possibilities) - 1):
         if len(to_add) > 0:
-            s += "|" + possibilities[i + 1] + to_add + " "
+            s += r"|" + possibilities[i + 1] + to_add + r" "
         else:
-            s += "|" + possibilities[i + 1]
-    return s + ")"
+            s += r"|" + possibilities[i + 1]
+    return s + r")"
 
 
 # Main tags
 llvm_IR_stmt_tags = [
-    # ['regex'                                                    'tag'                   'tag general'
+    # ['regex'                                                    r'tag'                   r'tag general'
     [
-        "<@ID> = (?!.*constant)(?!.*alias).*",
-        "global definition",
-        "global variable definition",
+        r"<@ID> = (?!.*constant)(?!.*alias).*",
+        r"global definition",
+        r"global variable definition",
     ],
-    ["<@ID> = .*constant .*", "global const. def.", "global variable definition"],
+    [r"<@ID> = .*constant .*", "global const. def.", "global variable definition"],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i1> .*",
-        "<d x i1> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i1> .*",
+        r"<d x i1> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i2> .*",
-        "<d x i2> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i2> .*",
+        r"<d x i2> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i4> .*",
-        "<d x i4> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i4> .*",
+        r"<d x i4> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i8> .*",
-        "<d x i8> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i8> .*",
+        r"<d x i8> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = add " + any_of(opt_addsubmul) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = add " + any_of(opt_addsubmul) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i1> .*",
-        "<d x i1> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i1> .*",
+        r"<d x i1> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i2> .*",
-        "<d x i2> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i2> .*",
+        r"<d x i2> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i4> .*",
-        "<d x i4> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i4> .*",
+        r"<d x i4> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i8> .*",
-        "<d x i8> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i8> .*",
+        r"<d x i8> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sub " + any_of(opt_addsubmul) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = sub " + any_of(opt_addsubmul) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i1> .*",
-        "<d x i1> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i1> .*",
+        r"<d x i1> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i2> .*",
-        "<d x i2> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i2> .*",
+        r"<d x i2> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i4> .*",
-        "<d x i4> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i4> .*",
+        r"<d x i4> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i8> .*",
-        "<d x i8> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i8> .*",
+        r"<d x i8> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = mul " + any_of(opt_addsubmul) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = mul " + any_of(opt_addsubmul) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i16> .*",
-        "<d x i16>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i16> .*",
+        r"<d x i16>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i32> .*",
-        "<d x i32>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i32> .*",
+        r"<d x i32>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i64> .*",
-        "<d x i64>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i64> .*",
+        r"<d x i64>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = udiv " + any_of(opt_usdiv) + "?<\d+ x i128> .*",
-        "<d x i128>  operation",
-        "<d x int> operation",
+        r"<%ID> = udiv " + any_of(opt_usdiv) + r"?<\d+ x i128> .*",
+        r"<d x i128>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i16> .*",
-        "<d x i16>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i16> .*",
+        r"<d x i16>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i32> .*",
-        "<d x i32>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i32> .*",
+        r"<d x i32>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i64> .*",
-        "<d x i64>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i64> .*",
+        r"<d x i64>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = sdiv " + any_of(opt_usdiv) + "?<\d+ x i128> .*",
-        "<d x i128>  operation",
-        "<d x int> operation",
+        r"<%ID> = sdiv " + any_of(opt_usdiv) + r"?<\d+ x i128> .*",
+        r"<d x i128>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<%ID> .*",
-        "struct  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<%ID> .*",
+        r"struct  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<%ID>\* .*",
-        "struct*  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<%ID>\* .*",
+        r"struct*  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<%ID>\*\* .*",
-        "struct**  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<%ID>\*\* .*",
+        r"struct**  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<%ID>\*\*\* .*",
-        "struct***  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<%ID>\*\*\* .*",
+        r"struct***  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i1> .*",
-        "<d x i1> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i1> .*",
+        r"<d x i1> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i2> .*",
-        "<d x i2> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i2> .*",
+        r"<d x i2> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i4> .*",
-        "<d x i4> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i4> .*",
+        r"<d x i4> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i8> .*",
-        "<d x i8> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i8> .*",
+        r"<d x i8> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i24 .*",
-        "i24 operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i24 .*",
+        r"i24 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i24> .*",
-        "<d x i24> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i24> .*",
+        r"<d x i24> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i40 .*",
-        "i40 operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i40 .*",
+        r"i40 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i40> .*",
-        "<d x i40> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i40> .*",
+        r"<d x i40> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i1\* .*",
-        "i1*  operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i1\* .*",
+        r"i1*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i2\* .*",
-        "i2*  operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i2\* .*",
+        r"i2*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i4\* .*",
-        "i4*  operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i4\* .*",
+        r"i4*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i8\* .*",
-        "i8*  operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i8\* .*",
+        r"i8*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i16\* .*",
-        "i16* operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i16\* .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i32\* .*",
-        "i32* operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i32\* .*",
+        r"i32* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i40\* .*",
-        "i40* operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i40\* .*",
+        r"i40* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i64\* .*",
-        "i64* operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i64\* .*",
+        r"i64* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i128\* .*",
-        "i128* operation",
-        "int* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i128\* .*",
+        r"i128* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?x86_fp80\* .*",
-        "float* operation",
-        "floating point* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?x86_fp80\* .*",
+        r"float* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?float\* .*",
-        "float* operation",
-        "floating point* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?float\* .*",
+        r"float* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?double\* .*",
-        "double* operation",
-        "floating point* operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?double\* .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i1\*\* .*",
-        "i1**  operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i1\*\* .*",
+        r"i1**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i2\*\* .*",
-        "i2**  operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i2\*\* .*",
+        r"i2**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i4\*\* .*",
-        "i4**  operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i4\*\* .*",
+        r"i4**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i8\*\* .*",
-        "i8**  operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i8\*\* .*",
+        r"i8**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i16\*\* .*",
-        "i16** operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i16\*\* .*",
+        r"i16** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i32\*\* .*",
-        "i32** operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i32\*\* .*",
+        r"i32** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i40\*\* .*",
-        "i40** operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i40\*\* .*",
+        r"i40** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i64\*\* .*",
-        "i64** operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i64\*\* .*",
+        r"i64** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?i128\*\* .*",
-        "i128** operation",
-        "int** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?i128\*\* .*",
+        r"i128** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?x86_fp80\*\* .*",
-        "float** operation",
-        "floating point** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?x86_fp80\*\* .*",
+        r"float** operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?float\*\* .*",
-        "float** operation",
-        "floating point** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?float\*\* .*",
+        r"float** operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?double\*\* .*",
-        "double** operation",
-        "floating point** operation",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?double\*\* .*",
+        r"double** operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<%ID>\* .*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<%ID>\* .*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + '?(%"|opaque).*',
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r'?(%"|opaque).*',
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?<?{.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?<?{.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = icmp " + any_of(opt_icmp) + "?void \(.*",
-        "function op",
-        "struct/class op",
+        r"<%ID> = icmp " + any_of(opt_icmp) + r"?void \(.*",
+        r"function op",
+        r"struct/class op",
     ],
-    ["<%ID> = srem i1 .*", "i1  operation", "int operation"],
-    ["<%ID> = srem <\d+ x i1> .*", "<d x i1>  operation", "<d x int> operation"],
-    ["<%ID> = srem i2 .*", "i2  operation", "int operation"],
-    ["<%ID> = srem <\d+ x i2> .*", "<d x i2>  operation", "<d x int> operation"],
-    ["<%ID> = srem i4 .*", "i4  operation", "int operation"],
-    ["<%ID> = srem <\d+ x i4> .*", "<d x i4>  operation", "<d x int> operation"],
-    ["<%ID> = srem i8 .*", "i8  operation", "int operation"],
-    ["<%ID> = srem <\d+ x i8> .*", "<d x i8>  operation", "<d x int> operation"],
-    ["<%ID> = srem i16 .*", "i16 operation", "int operation"],
+    [r"<%ID> = srem i1 .*", "i1  operation", "int operation"],
+    [r"<%ID> = srem <\d+ x i1> .*", "<d x i1>  operation", "<d x int> operation"],
+    [r"<%ID> = srem i2 .*", "i2  operation", "int operation"],
+    [r"<%ID> = srem <\d+ x i2> .*", "<d x i2>  operation", "<d x int> operation"],
+    [r"<%ID> = srem i4 .*", "i4  operation", "int operation"],
+    [r"<%ID> = srem <\d+ x i4> .*", "<d x i4>  operation", "<d x int> operation"],
+    [r"<%ID> = srem i8 .*", "i8  operation", "int operation"],
+    [r"<%ID> = srem <\d+ x i8> .*", "<d x i8>  operation", "<d x int> operation"],
+    [r"<%ID> = srem i16 .*", "i16 operation", "int operation"],
     [
-        "<%ID> = srem <\d+ x i16> .*",
-        "<d x i16>  operation",
-        "<d x int> operation",
+        r"<%ID> = srem <\d+ x i16> .*",
+        r"<d x i16>  operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = srem i32 .*", "i32 operation", "int operation"],
+    [r"<%ID> = srem i32 .*", "i32 operation", "int operation"],
     [
-        "<%ID> = srem <\d+ x i32> .*",
-        "<d x i32>  operation",
-        "<d x int> operation",
+        r"<%ID> = srem <\d+ x i32> .*",
+        r"<d x i32>  operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = srem i64 .*", "i64 operation", "int operation"],
+    [r"<%ID> = srem i64 .*", "i64 operation", "int operation"],
     [
-        "<%ID> = srem <\d+ x i64> .*",
-        "<d x i64>  operation",
-        "<d x int> operation",
+        r"<%ID> = srem <\d+ x i64> .*",
+        r"<d x i64>  operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = srem i128 .*", "i128 operation", "int operation"],
+    [r"<%ID> = srem i128 .*", "i128 operation", "int operation"],
     [
-        "<%ID> = srem <\d+ x i128> .*",
-        "<d x i128>  operation",
-        "<d x int> operation",
+        r"<%ID> = srem <\d+ x i128> .*",
+        r"<d x i128>  operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = urem i1 .*", "i1  operation", "int operation"],
-    ["<%ID> = urem <\d+ x i1> .*", "<d x i1>  operation", "<d x int> operation"],
-    ["<%ID> = urem i2 .*", "i2  operation", "int operation"],
-    ["<%ID> = urem <\d+ x i2> .*", "<d x i2>  operation", "<d x int> operation"],
-    ["<%ID> = urem i4 .*", "i4  operation", "int operation"],
-    ["<%ID> = urem <\d+ x i4> .*", "<d x i4>  operation", "<d x int> operation"],
-    ["<%ID> = urem i8 .*", "i8  operation", "int operation"],
-    ["<%ID> = urem <\d+ x i8> .*", "<d x i8>  operation", "<d x int> operation"],
-    ["<%ID> = urem i16 .*", "i16 operation", "int operation"],
+    [r"<%ID> = urem i1 .*", "i1  operation", "int operation"],
+    [r"<%ID> = urem <\d+ x i1> .*", "<d x i1>  operation", "<d x int> operation"],
+    [r"<%ID> = urem i2 .*", "i2  operation", "int operation"],
+    [r"<%ID> = urem <\d+ x i2> .*", "<d x i2>  operation", "<d x int> operation"],
+    [r"<%ID> = urem i4 .*", "i4  operation", "int operation"],
+    [r"<%ID> = urem <\d+ x i4> .*", "<d x i4>  operation", "<d x int> operation"],
+    [r"<%ID> = urem i8 .*", "i8  operation", "int operation"],
+    [r"<%ID> = urem <\d+ x i8> .*", "<d x i8>  operation", "<d x int> operation"],
+    [r"<%ID> = urem i16 .*", "i16 operation", "int operation"],
     [
-        "<%ID> = urem <\d+ x i16> .*",
-        "<d x i16>  operation",
-        "<d x int> operation",
+        r"<%ID> = urem <\d+ x i16> .*",
+        r"<d x i16>  operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = urem i32 .*", "i32 operation", "int operation"],
+    [r"<%ID> = urem i32 .*", "i32 operation", "int operation"],
     [
-        "<%ID> = urem <\d+ x i32> .*",
-        "<d x i32>  operation",
-        "<d x int> operation",
+        r"<%ID> = urem <\d+ x i32> .*",
+        r"<d x i32>  operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = urem i64 .*", "i32 operation", "int operation"],
+    [r"<%ID> = urem i64 .*", "i32 operation", "int operation"],
     [
-        "<%ID> = urem <\d+ x i64> .*",
-        "<d x i64>  operation",
-        "<d x int> operation",
+        r"<%ID> = urem <\d+ x i64> .*",
+        r"<d x i64>  operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = urem i128 .*", "i128 operation", "int operation"],
+    [r"<%ID> = urem i128 .*", "i128 operation", "int operation"],
     [
-        "<%ID> = urem <\d+ x i128> .*",
-        "<d x i128>  operation",
-        "<d x int> operation",
+        r"<%ID> = urem <\d+ x i128> .*",
+        r"<d x i128>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = fadd " + any_of(fast_math_flag) + "?x86_fp80.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fadd " + any_of(fast_math_flag) + r"?x86_fp80.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fadd " + any_of(fast_math_flag) + "?<\d+ x x86_fp80>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fadd " + any_of(fast_math_flag) + r"?<\d+ x x86_fp80>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fadd " + any_of(fast_math_flag) + "?float.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fadd " + any_of(fast_math_flag) + r"?float.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fadd " + any_of(fast_math_flag) + "?<\d+ x float>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fadd " + any_of(fast_math_flag) + r"?<\d+ x float>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fadd " + any_of(fast_math_flag) + "?double.*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = fadd " + any_of(fast_math_flag) + r"?double.*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fadd " + any_of(fast_math_flag) + "?<\d+ x double>.*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fadd " + any_of(fast_math_flag) + r"?<\d+ x double>.*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fsub " + any_of(fast_math_flag) + "?x86_fp80.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fsub " + any_of(fast_math_flag) + r"?x86_fp80.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fsub " + any_of(fast_math_flag) + "?<\d+ x x86_fp80>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fsub " + any_of(fast_math_flag) + r"?<\d+ x x86_fp80>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fsub " + any_of(fast_math_flag) + "?float.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fsub " + any_of(fast_math_flag) + r"?float.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fsub " + any_of(fast_math_flag) + "?<\d+ x float>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fsub " + any_of(fast_math_flag) + r"?<\d+ x float>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fsub " + any_of(fast_math_flag) + "?double.*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = fsub " + any_of(fast_math_flag) + r"?double.*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fsub " + any_of(fast_math_flag) + "?<\d+ x double>.*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fsub " + any_of(fast_math_flag) + r"?<\d+ x double>.*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fmul " + any_of(fast_math_flag) + "?x86_fp80.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fmul " + any_of(fast_math_flag) + r"?x86_fp80.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fmul " + any_of(fast_math_flag) + "?<\d+ x x86_fp80>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fmul " + any_of(fast_math_flag) + r"?<\d+ x x86_fp80>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fmul " + any_of(fast_math_flag) + "?float.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fmul " + any_of(fast_math_flag) + r"?float.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fmul " + any_of(fast_math_flag) + "?<\d+ x float>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fmul " + any_of(fast_math_flag) + r"?<\d+ x float>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fmul " + any_of(fast_math_flag) + "?double.*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = fmul " + any_of(fast_math_flag) + r"?double.*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fmul " + any_of(fast_math_flag) + "?<\d+ x double>.*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fmul " + any_of(fast_math_flag) + r"?<\d+ x double>.*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fdiv " + any_of(fast_math_flag) + "?x86_fp80.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fdiv " + any_of(fast_math_flag) + r"?x86_fp80.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fdiv " + any_of(fast_math_flag) + "?<\d+ x x86_fp80>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fdiv " + any_of(fast_math_flag) + r"?<\d+ x x86_fp80>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fdiv " + any_of(fast_math_flag) + "?float.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fdiv " + any_of(fast_math_flag) + r"?float.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fdiv " + any_of(fast_math_flag) + "?<\d+ x float>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fdiv " + any_of(fast_math_flag) + r"?<\d+ x float>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fdiv " + any_of(fast_math_flag) + "?double.*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = fdiv " + any_of(fast_math_flag) + r"?double.*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fdiv " + any_of(fast_math_flag) + "?<\d+ x double>.*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fdiv " + any_of(fast_math_flag) + r"?<\d+ x double>.*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = frem " + any_of(fast_math_flag) + "?x86_fp80.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = frem " + any_of(fast_math_flag) + r"?x86_fp80.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = frem " + any_of(fast_math_flag) + "?<\d+ x x86_fp80>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = frem " + any_of(fast_math_flag) + r"?<\d+ x x86_fp80>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = frem " + any_of(fast_math_flag) + "?float.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = frem " + any_of(fast_math_flag) + r"?float.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = frem " + any_of(fast_math_flag) + "?<\d+ x float>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = frem " + any_of(fast_math_flag) + r"?<\d+ x float>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = frem " + any_of(fast_math_flag) + "?double.*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = frem " + any_of(fast_math_flag) + r"?double.*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = frem " + any_of(fast_math_flag) + "?<\d+ x double>.*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = frem " + any_of(fast_math_flag) + r"?<\d+ x double>.*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + "?x86_fp80.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + r"?x86_fp80.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + "?<\d+ x x86_fp80>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + r"?<\d+ x x86_fp80>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + "?float.*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + r"?float.*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + "?<\d+ x float>.*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + r"?<\d+ x float>.*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + "?double.*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + r"?double.*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + "?<\d+ x double>.*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = fcmp (fast |)?" + any_of(opt_fcmp) + r"?<\d+ x double>.*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
-    ["<%ID> = atomicrmw add i1\* .*", "i1* operation", "int* operation"],
-    ["<%ID> = atomicrmw add i2\* .*", "i2* operation", "int* operation"],
-    ["<%ID> = atomicrmw add i4\* .*", "i4* operation", "int* operation"],
-    ["<%ID> = atomicrmw add i8\* .*", "i8* operation", "int* operation"],
-    ["<%ID> = atomicrmw add i16\* .*", "i16* operation", "int* operation"],
-    ["<%ID> = atomicrmw add i32\* .*", "i32* operation", "int* operation"],
-    ["<%ID> = atomicrmw add i64\* .*", "i64* operation", "int* operation"],
-    ["<%ID> = atomicrmw add i128\* .*", "i128* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i1\* .*", "i1* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i2\* .*", "i2* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i4\* .*", "i4* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i8\* .*", "i8* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i16\* .*", "i16* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i32\* .*", "i32* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i64\* .*", "i64* operation", "int* operation"],
-    ["<%ID> = atomicrmw sub i128\* .*", "i128* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i1\* .*", "i1* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i2\* .*", "i2* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i4\* .*", "i4* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i8\* .*", "i8* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i16\* .*", "i16* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i32\* .*", "i32* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i64\* .*", "i64* operation", "int* operation"],
-    ["<%ID> = atomicrmw or i128\* .*", "i128* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i1\* .*", "i1* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i2\* .*", "i2* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i4\* .*", "i4* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i8\* .*", "i8* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i16\* .*", "i16* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i32\* .*", "i32* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i64\* .*", "i64* operation", "int* operation"],
-    ["<%ID> = atomicrmw xchg i128\* .*", "i128* operation", "int* operation"],
-    ["<%ID> = alloca i1($|,).*", "i1  operation", "int operation"],
-    ["<%ID> = alloca i2($|,).*", "i2  operation", "int operation"],
-    ["<%ID> = alloca i4($|,).*", "i4  operation", "int operation"],
-    ["<%ID> = alloca i8($|,).*", "i8  operation", "int operation"],
-    ["<%ID> = alloca i16($|,).*", "i16 operation", "int operation"],
-    ["<%ID> = alloca i32($|,).*", "i32 operation", "int operation"],
-    ["<%ID> = alloca i64($|,).*", "i64 operation", "int operation"],
-    ["<%ID> = alloca i128($|,).*", "i128 operation", "int operation"],
-    ["<%ID> = alloca i1\*($|,).*", "i1*  operation", "int* operation"],
-    ["<%ID> = alloca i2\*($|,).*", "i2*  operation", "int* operation"],
-    ["<%ID> = alloca i4\*($|,).*", "i4*  operation", "int* operation"],
-    ["<%ID> = alloca i8\*($|,).*", "i8*  operation", "int* operation"],
-    ["<%ID> = alloca i16\*($|,).*", "i16* operation", "int* operation"],
-    ["<%ID> = alloca i32\*($|,).*", "i32* operation", "int* operation"],
-    ["<%ID> = alloca i64\*($|,).*", "i64* operation", "int* operation"],
-    ["<%ID> = alloca i128\*($|,).*", "i128* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i1\* .*", "i1* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i2\* .*", "i2* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i4\* .*", "i4* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i8\* .*", "i8* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i16\* .*", "i16* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i32\* .*", "i32* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i64\* .*", "i64* operation", "int* operation"],
+    [r"<%ID> = atomicrmw add i128\* .*", "i128* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i1\* .*", "i1* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i2\* .*", "i2* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i4\* .*", "i4* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i8\* .*", "i8* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i16\* .*", "i16* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i32\* .*", "i32* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i64\* .*", "i64* operation", "int* operation"],
+    [r"<%ID> = atomicrmw sub i128\* .*", "i128* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i1\* .*", "i1* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i2\* .*", "i2* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i4\* .*", "i4* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i8\* .*", "i8* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i16\* .*", "i16* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i32\* .*", "i32* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i64\* .*", "i64* operation", "int* operation"],
+    [r"<%ID> = atomicrmw or i128\* .*", "i128* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i1\* .*", "i1* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i2\* .*", "i2* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i4\* .*", "i4* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i8\* .*", "i8* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i16\* .*", "i16* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i32\* .*", "i32* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i64\* .*", "i64* operation", "int* operation"],
+    [r"<%ID> = atomicrmw xchg i128\* .*", "i128* operation", "int* operation"],
+    [r"<%ID> = alloca i1($|,).*", "i1  operation", "int operation"],
+    [r"<%ID> = alloca i2($|,).*", "i2  operation", "int operation"],
+    [r"<%ID> = alloca i4($|,).*", "i4  operation", "int operation"],
+    [r"<%ID> = alloca i8($|,).*", "i8  operation", "int operation"],
+    [r"<%ID> = alloca i16($|,).*", "i16 operation", "int operation"],
+    [r"<%ID> = alloca i32($|,).*", "i32 operation", "int operation"],
+    [r"<%ID> = alloca i64($|,).*", "i64 operation", "int operation"],
+    [r"<%ID> = alloca i128($|,).*", "i128 operation", "int operation"],
+    [r"<%ID> = alloca i1\*($|,).*", "i1*  operation", "int* operation"],
+    [r"<%ID> = alloca i2\*($|,).*", "i2*  operation", "int* operation"],
+    [r"<%ID> = alloca i4\*($|,).*", "i4*  operation", "int* operation"],
+    [r"<%ID> = alloca i8\*($|,).*", "i8*  operation", "int* operation"],
+    [r"<%ID> = alloca i16\*($|,).*", "i16* operation", "int* operation"],
+    [r"<%ID> = alloca i32\*($|,).*", "i32* operation", "int* operation"],
+    [r"<%ID> = alloca i64\*($|,).*", "i64* operation", "int* operation"],
+    [r"<%ID> = alloca i128\*($|,).*", "i128* operation", "int* operation"],
     [
-        "<%ID> = alloca x86_fp80($|,).*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = alloca x86_fp80($|,).*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = alloca float($|,).*",
-        "float  operation",
-        "floating point operation",
-    ],
-    [
-        "<%ID> = alloca double($|,).*",
-        "double operation",
-        "floating point operation",
-    ],
-    [
-        "<%ID> = alloca x86_fp80\*($|,).*",
-        "float*  operation",
-        "floating point* operation",
-    ],
-    [
-        "<%ID> = alloca float\*($|,).*",
-        "float*  operation",
-        "floating point* operation",
-    ],
-    [
-        "<%ID> = alloca double\*($|,).*",
-        "double* operation",
-        "floating point* operation",
+        r"<%ID> = alloca float($|,).*",
+        r"float  operation",
+        r"floating point operation",
+    ],
+    [
+        r"<%ID> = alloca double($|,).*",
+        r"double operation",
+        r"floating point operation",
+    ],
+    [
+        r"<%ID> = alloca x86_fp80\*($|,).*",
+        r"float*  operation",
+        r"floating point* operation",
+    ],
+    [
+        r"<%ID> = alloca float\*($|,).*",
+        r"float*  operation",
+        r"floating point* operation",
+    ],
+    [
+        r"<%ID> = alloca double\*($|,).*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     ['<%ID> = alloca %".*', "struct/class op", "struct/class op"],
-    ["<%ID> = alloca <%.*", "struct/class op", "struct/class op"],
-    ["<%ID> = alloca <?{.*", "struct/class op", "struct/class op"],
-    ["<%ID> = alloca opaque.*", "struct/class op", "struct/class op"],
+    [r"<%ID> = alloca <%.*", "struct/class op", "struct/class op"],
+    [r"<%ID> = alloca <?{.*", "struct/class op", "struct/class op"],
+    [r"<%ID> = alloca opaque.*", "struct/class op", "struct/class op"],
     [
-        "<%ID> = alloca <\d+ x i1>, .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i1>, .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i2>, .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i2>, .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i4>, .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i4>, .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i8>, .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i8>, .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i16>, .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i16>, .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i32>, .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i32>, .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i64>, .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i64>, .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i128>, .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = alloca <\d+ x i128>, .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x x86_fp80>, .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = alloca <\d+ x x86_fp80>, .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x float>, .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = alloca <\d+ x float>, .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x double>, .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = alloca <\d+ x double>, .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x \{ .* \}>, .*",
-        "<d x structure> operation",
-        "<d x structure> operation",
+        r"<%ID> = alloca <\d+ x \{ .* \}>, .*",
+        r"<d x structure> operation",
+        r"<d x structure> operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i1>\*, .*",
-        "<d x i1>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i1>\*, .*",
+        r"<d x i1>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i2>\*, .*",
-        "<d x i2>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i2>\*, .*",
+        r"<d x i2>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i4>\*, .*",
-        "<d x i4>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i4>\*, .*",
+        r"<d x i4>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i8>\*, .*",
-        "<d x i8>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i8>\*, .*",
+        r"<d x i8>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i16>\*, .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i16>\*, .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i32>\*, .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i32>\*, .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i64>\*, .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i64>\*, .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x i128>\*, .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        r"<%ID> = alloca <\d+ x i128>\*, .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x x86_fp80>\*, .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = alloca <\d+ x x86_fp80>\*, .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x float>\*, .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = alloca <\d+ x float>\*, .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x double>\*, .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = alloca <\d+ x double>\*, .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = alloca <\d+ x \{ .* \}>\*, .*",
-        "<d x structure>* operation",
-        "<d x structure>* operation",
+        r"<%ID> = alloca <\d+ x \{ .* \}>\*, .*",
+        r"<d x structure>* operation",
+        r"<d x structure>* operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i1\], .*",
-        "[d x i1]  operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i1\], .*",
+        r"[d x i1]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i2\], .*",
-        "[d x i2]  operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i2\], .*",
+        r"[d x i2]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i4\], .*",
-        "[d x i4]  operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i4\], .*",
+        r"[d x i4]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i8\], .*",
-        "[d x i8]  operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i8\], .*",
+        r"[d x i8]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i16\], .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i16\], .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i32\], .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i32\], .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i64\], .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i64\], .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x i128\], .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        r"<%ID> = alloca \[\d+ x i128\], .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x x86_fp80\], .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"<%ID> = alloca \[\d+ x x86_fp80\], .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x float\], .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"<%ID> = alloca \[\d+ x float\], .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x double\], .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
+        r"<%ID> = alloca \[\d+ x double\], .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = alloca \[\d+ x \{ .* \}\], .*",
-        "[d x structure] operation",
-        "[d x structure] operation",
+        r"<%ID> = alloca \[\d+ x \{ .* \}\], .*",
+        r"[d x structure] operation",
+        r"[d x structure] operation",
     ],
     [
-        "<%ID> = alloca { { float, float } }, .*",
-        "{ float, float } operation",
-        "complex operation",
+        r"<%ID> = alloca { { float, float } }, .*",
+        r"{ float, float } operation",
+        r"complex operation",
     ],
     [
-        "<%ID> = alloca { { double, double } }, .*",
-        "{ double, double } operation",
-        "complex operation",
+        r"<%ID> = alloca { { double, double } }, .*",
+        r"{ double, double } operation",
+        r"complex operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i1, .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i1, .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i2, .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i2, .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i4, .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i4, .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i8, .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i8, .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i16, .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i16, .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i24, .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i24, .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i32, .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i32, .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i40, .*",
-        "i40 operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i40, .*",
+        r"i40 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i64, .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i64, .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i128, .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i128, .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i256, .*",
-        "i256 operation",
-        "int operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i256, .*",
+        r"i256 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i1\*, .*",
-        "i1*  operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i1\*, .*",
+        r"i1*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i2\*, .*",
-        "i2*  operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i2\*, .*",
+        r"i2*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i4\*, .*",
-        "i4*  operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i4\*, .*",
+        r"i4*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i8\*, .*",
-        "i8*  operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i8\*, .*",
+        r"i8*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i16\*, .*",
-        "i16* operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i16\*, .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i24\*, .*",
-        "i16* operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i24\*, .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i32\*, .*",
-        "i32* operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i32\*, .*",
+        r"i32* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i40\*, .*",
-        "i40* operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i40\*, .*",
+        r"i40* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i64\*, .*",
-        "i64* operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i64\*, .*",
+        r"i64* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i128\*, .*",
-        "i128* operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i128\*, .*",
+        r"i128* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i256\*, .*",
-        "i256* operation",
-        "int* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i256\*, .*",
+        r"i256* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i1\*\*, .*",
-        "i1**  operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i1\*\*, .*",
+        r"i1**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i2\*\*, .*",
-        "i2**  operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i2\*\*, .*",
+        r"i2**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i4\*\*, .*",
-        "i4**  operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i4\*\*, .*",
+        r"i4**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i8\*\*, .*",
-        "i8**  operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i8\*\*, .*",
+        r"i8**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i16\*\*, .*",
-        "i16** operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i16\*\*, .*",
+        r"i16** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i24\*\*, .*",
-        "i16** operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i24\*\*, .*",
+        r"i16** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i32\*\*, .*",
-        "i32** operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i32\*\*, .*",
+        r"i32** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i40\*\*, .*",
-        "i40** operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i40\*\*, .*",
+        r"i40** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i64\*\*, .*",
-        "i64** operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i64\*\*, .*",
+        r"i64** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i128\*\*, .*",
-        "i128** operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i128\*\*, .*",
+        r"i128** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i256\*\*, .*",
-        "i256** operation",
-        "int** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i256\*\*, .*",
+        r"i256** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i1\*\*\*, .*",
-        "i1***  operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i1\*\*\*, .*",
+        r"i1***  operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i2\*\*\*, .*",
-        "i2***  operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i2\*\*\*, .*",
+        r"i2***  operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i4\*\*\*, .*",
-        "i4***  operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i4\*\*\*, .*",
+        r"i4***  operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i8\*\*\*, .*",
-        "i8***  operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i8\*\*\*, .*",
+        r"i8***  operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i16\*\*\*, .*",
-        "i16*** operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i16\*\*\*, .*",
+        r"i16*** operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i24\*\*\*, .*",
-        "i16*** operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i24\*\*\*, .*",
+        r"i16*** operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i32\*\*\*, .*",
-        "i32*** operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i32\*\*\*, .*",
+        r"i32*** operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i40\*\*\*, .*",
-        "i40*** operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i40\*\*\*, .*",
+        r"i40*** operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i64\*\*\*, .*",
-        "i64*** operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i64\*\*\*, .*",
+        r"i64*** operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i128\*\*\*, .*",
-        "i128*** operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i128\*\*\*, .*",
+        r"i128*** operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?i256\*\*\*, .*",
-        "i256*** operation",
-        "int*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?i256\*\*\*, .*",
+        r"i256*** operation",
+        r"int*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?x86_fp80, .*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?x86_fp80, .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?float, .*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?float, .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?double, .*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?double, .*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?x86_fp80\*, .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?x86_fp80\*, .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?float\*, .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?float\*, .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?double\*, .*",
-        "double* operation",
-        "floating point* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?double\*, .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?x86_fp80\*\*, .*",
-        "float**  operation",
-        "floating point** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?x86_fp80\*\*, .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?float\*\*, .*",
-        "float**  operation",
-        "floating point** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?float\*\*, .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?double\*\*, .*",
-        "double** operation",
-        "floating point** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?double\*\*, .*",
+        r"double** operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?x86_fp80\*\*\*, .*",
-        "float***  operation",
-        "floating point*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?x86_fp80\*\*\*, .*",
+        r"float***  operation",
+        r"floating point*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?float\*\*\*, .*",
-        "float***  operation",
-        "floating point*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?float\*\*\*, .*",
+        r"float***  operation",
+        r"floating point*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?double\*\*\*, .*",
-        "double*** operation",
-        "floating point*** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?double\*\*\*, .*",
+        r"double*** operation",
+        r"floating point*** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + '?%".*',
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = load " + any_of(opt_load) + r'?%".*',
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<%.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = load " + any_of(opt_load) + r"?<%.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<?{.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = load " + any_of(opt_load) + r"?<?{.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?opaque.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = load " + any_of(opt_load) + r"?opaque.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i1>, .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i1>, .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i2>, .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i2>, .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i4>, .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i4>, .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i8>, .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i8>, .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i16>, .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i16>, .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i24>, .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i24>, .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i32>, .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i32>, .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i40>, .*",
-        "<d x i40> operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i40>, .*",
+        r"<d x i40> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i64>, .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i64>, .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i128>, .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i128>, .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x x86_fp80>, .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x x86_fp80>, .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x float>, .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x float>, .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x double>, .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x double>, .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x \{ .* \}>, .*",
-        "<d x structure> operation",
-        "<d x structure> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x \{ .* \}>, .*",
+        r"<d x structure> operation",
+        r"<d x structure> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i1\*>, .*",
-        "<d x i1*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i1\*>, .*",
+        r"<d x i1*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i2\*>, .*",
-        "<d x i2*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i2\*>, .*",
+        r"<d x i2*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i4\*>, .*",
-        "<d x i4*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i4\*>, .*",
+        r"<d x i4*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i8\*>, .*",
-        "<d x i8*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i8\*>, .*",
+        r"<d x i8*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i16\*>, .*",
-        "<d x i16*> operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i16\*>, .*",
+        r"<d x i16*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i24\*>, .*",
-        "<d x i16*> operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i24\*>, .*",
+        r"<d x i16*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i32\*>, .*",
-        "<d x i32*> operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i32\*>, .*",
+        r"<d x i32*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i40\*>, .*",
-        "<d x i40*> operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i40\*>, .*",
+        r"<d x i40*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i64\*>, .*",
-        "<d x i64*> operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i64\*>, .*",
+        r"<d x i64*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i128\*>, .*",
-        "<d x i128*> operation",
-        "<d x int*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i128\*>, .*",
+        r"<d x i128*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x x86_fp80\*>, .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x x86_fp80\*>, .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x float\*>, .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x float\*>, .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x double\*>, .*",
-        "<d x double*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x double\*>, .*",
+        r"<d x double*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i1>\*, .*",
-        "<d x i1>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i1>\*, .*",
+        r"<d x i1>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i2>\*, .*",
-        "<d x i2>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i2>\*, .*",
+        r"<d x i2>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i4>\*, .*",
-        "<d x i4>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i4>\*, .*",
+        r"<d x i4>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i8>\*, .*",
-        "<d x i8>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i8>\*, .*",
+        r"<d x i8>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i16>\*, .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i16>\*, .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i24>\*, .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i24>\*, .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i32>\*, .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i32>\*, .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i40>\*, .*",
-        "<d x i40>* operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i40>\*, .*",
+        r"<d x i40>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i64>\*, .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i64>\*, .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x i128>\*, .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x i128>\*, .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x x86_fp80>\*, .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x x86_fp80>\*, .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x float>\*, .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x float>\*, .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x double>\*, .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x double>\*, .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x \{ .* \}>\*, .*",
-        "<d x structure>* operation",
-        "<d x structure>* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x \{ .* \}>\*, .*",
+        r"<d x structure>* operation",
+        r"<d x structure>* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x x86_fp80>\*\*, .*",
-        "<d x float>** operation",
-        "<d x floating point>** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x x86_fp80>\*\*, .*",
+        r"<d x float>** operation",
+        r"<d x floating point>** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x float>\*\*, .*",
-        "<d x float>** operation",
-        "<d x floating point>** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x float>\*\*, .*",
+        r"<d x float>** operation",
+        r"<d x floating point>** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x double>\*\*, .*",
-        "<d x double>** operation",
-        "<d x floating point>** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x double>\*\*, .*",
+        r"<d x double>** operation",
+        r"<d x floating point>** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?<\d+ x \{ .* \}>\*\*, .*",
-        "<d x structure>** operation",
-        "<d x structure>** operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?<\d+ x \{ .* \}>\*\*, .*",
+        r"<d x structure>** operation",
+        r"<d x structure>** operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i1\], .*",
-        "[d x i1]  operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i1\], .*",
+        r"[d x i1]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i2\], .*",
-        "[d x i2]  operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i2\], .*",
+        r"[d x i2]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i4\], .*",
-        "[d x i4]  operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i4\], .*",
+        r"[d x i4]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i8\], .*",
-        "[d x i8]  operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i8\], .*",
+        r"[d x i8]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i16\], .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i16\], .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i24\], .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i24\], .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i32\], .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i32\], .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i40\], .*",
-        "[d x i40] operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i40\], .*",
+        r"[d x i40] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i64\], .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i64\], .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i128\], .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i128\], .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x x86_fp80\], .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x x86_fp80\], .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x float\], .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x float\], .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x double\], .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x double\], .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x \{ .* \}\], .*",
-        "[d x structure] operation",
-        "[d x structure] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x \{ .* \}\], .*",
+        r"[d x structure] operation",
+        r"[d x structure] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i1\]\*, .*",
-        "[d x i1]*  operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i1\]\*, .*",
+        r"[d x i1]*  operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i2\]\*, .*",
-        "[d x i2]*  operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i2\]\*, .*",
+        r"[d x i2]*  operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i4\]\*, .*",
-        "[d x i4]*  operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i4\]\*, .*",
+        r"[d x i4]*  operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i8\]\*, .*",
-        "[d x i8]*  operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i8\]\*, .*",
+        r"[d x i8]*  operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i16\]\*, .*",
-        "[d x i16]* operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i16\]\*, .*",
+        r"[d x i16]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i32\]\*, .*",
-        "[d x i32]* operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i32\]\*, .*",
+        r"[d x i32]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i40\]\*, .*",
-        "[d x i40]* operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i40\]\*, .*",
+        r"[d x i40]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i64\]\*, .*",
-        "[d x i64]* operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i64\]\*, .*",
+        r"[d x i64]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x i128\]\*, .*",
-        "[d x i128]* operation",
-        "[d x int]* operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x i128\]\*, .*",
+        r"[d x i128]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x x86_fp80\]\*, .*",
-        "[d x float]* operation",
-        "[d x floating point] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x x86_fp80\]\*, .*",
+        r"[d x float]* operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x float\]\*, .*",
-        "[d x float]* operation",
-        "[d x floating point] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x float\]\*, .*",
+        r"[d x float]* operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x double\]\*, .*",
-        "[d x double]* operation",
-        "[d x floating point] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x double\]\*, .*",
+        r"[d x double]* operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?\[\d+ x \{ .* \}\]\*, .*",
-        "[d x structure]* operation",
-        "[d x floating point] operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?\[\d+ x \{ .* \}\]\*, .*",
+        r"[d x structure]* operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = load " + any_of(opt_load) + "?.*\(.*\)\*+, .*",
-        "function operation",
-        "function operation",
+        r"<%ID> = load " + any_of(opt_load) + r"?.*\(.*\)\*+, .*",
+        r"function operation",
+        r"function operation",
     ],
-    ["store " + any_of(opt_load) + "?i1 .*", "i1  operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i2 .*", "i2  operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i4 .*", "i4  operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i8 .*", "i8  operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i16 .*", "i16 operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i24 .*", "i16 operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i32 .*", "i32 operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i40 .*", "i32 operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i64 .*", "i64 operation", "int operation"],
-    ["store " + any_of(opt_load) + "?i128 .*", "i128 operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i1 .*", "i1  operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i2 .*", "i2  operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i4 .*", "i4  operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i8 .*", "i8  operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i16 .*", "i16 operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i24 .*", "i16 operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i32 .*", "i32 operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i40 .*", "i32 operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i64 .*", "i64 operation", "int operation"],
+    [r"store " + any_of(opt_load) + r"?i128 .*", "i128 operation", "int operation"],
     [
-        "store " + any_of(opt_load) + "?i1\* .*",
-        "i1*  operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i1\* .*",
+        r"i1*  operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i2\* .*",
-        "i2*  operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i2\* .*",
+        r"i2*  operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i4\* .*",
-        "i4*  operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i4\* .*",
+        r"i4*  operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i8\* .*",
-        "i8*  operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i8\* .*",
+        r"i8*  operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i16\* .*",
-        "i16* operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i16\* .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i32\* .*",
-        "i32* operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i32\* .*",
+        r"i32* operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i64\* .*",
-        "i64* operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i64\* .*",
+        r"i64* operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i128\* .*",
-        "i128* operation",
-        "int* operation",
+        r"store " + any_of(opt_load) + r"?i128\* .*",
+        r"i128* operation",
+        r"int* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i1\*\* .*",
-        "i1**  operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i1\*\* .*",
+        r"i1**  operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i2\*\* .*",
-        "i2**  operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i2\*\* .*",
+        r"i2**  operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i4\*\* .*",
-        "i4**  operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i4\*\* .*",
+        r"i4**  operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i8\*\* .*",
-        "i8**  operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i8\*\* .*",
+        r"i8**  operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i16\*\* .*",
-        "i16** operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i16\*\* .*",
+        r"i16** operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i32\*\* .*",
-        "i32** operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i32\*\* .*",
+        r"i32** operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i64\*\* .*",
-        "i64** operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i64\*\* .*",
+        r"i64** operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?i128\*\* .*",
-        "i128** operation",
-        "int** operation",
+        r"store " + any_of(opt_load) + r"?i128\*\* .*",
+        r"i128** operation",
+        r"int** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?x86_fp80 .*",
-        "float  operation",
-        "floating point operation",
+        r"store " + any_of(opt_load) + r"?x86_fp80 .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "store " + any_of(opt_load) + "?float .*",
-        "float  operation",
-        "floating point operation",
+        r"store " + any_of(opt_load) + r"?float .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "store " + any_of(opt_load) + "?double .*",
-        "double operation",
-        "floating point operation",
+        r"store " + any_of(opt_load) + r"?double .*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "store " + any_of(opt_load) + "?x86_fp80\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"store " + any_of(opt_load) + r"?x86_fp80\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?float\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"store " + any_of(opt_load) + r"?float\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?double\* .*",
-        "double* operation",
-        "floating point* operation",
+        r"store " + any_of(opt_load) + r"?double\* .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?x86_fp80\*\* .*",
-        "float**  operation",
-        "floating point** operation",
+        r"store " + any_of(opt_load) + r"?x86_fp80\*\* .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?float\*\* .*",
-        "float**  operation",
-        "floating point** operation",
+        r"store " + any_of(opt_load) + r"?float\*\* .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "store " + any_of(opt_load) + "?double\*\* .*",
-        "double** operation",
-        "floating point** operation",
+        r"store " + any_of(opt_load) + r"?double\*\* .*",
+        r"double** operation",
+        r"floating point** operation",
     ],
-    ["store " + any_of(opt_load) + "?void \(.*", "function op", "function op"],
-    ["store " + any_of(opt_load) + '?%".*', "struct/class op", "struct/class op"],
-    ["store " + any_of(opt_load) + "?<%.*", "struct/class op", "struct/class op"],
+    [r"store " + any_of(opt_load) + r"?void \(.*", "function op", "function op"],
+    [r"store " + any_of(opt_load) + r'?%".*', "struct/class op", "struct/class op"],
+    [r"store " + any_of(opt_load) + r"?<%.*", "struct/class op", "struct/class op"],
     [
-        "store " + any_of(opt_load) + "?<?{.*",
-        "struct/class op",
-        "struct/class op",
+        r"store " + any_of(opt_load) + r"?<?{.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "store " + any_of(opt_load) + "?opaque.*",
-        "struct/class op",
-        "struct/class op",
+        r"store " + any_of(opt_load) + r"?opaque.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x \{ .* \}> .*",
-        "<d x \{ .* \}> operation",
-        "<d x \{ .* \}> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x \{ .* \}> .*",
+        r"<d x \{ .* \}> operation",
+        r"<d x \{ .* \}> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i1\*> .*",
-        "<d x i1*>  operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i1\*> .*",
+        r"<d x i1*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i2\*> .*",
-        "<d x i2*>  operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i2\*> .*",
+        r"<d x i2*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i4\*> .*",
-        "<d x i4*>  operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i4\*> .*",
+        r"<d x i4*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i8\*> .*",
-        "<d x i8*>  operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i8\*> .*",
+        r"<d x i8*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i16\*> .*",
-        "<d x i16*> operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i16\*> .*",
+        r"<d x i16*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i32\*> .*",
-        "<d x i32*> operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i32\*> .*",
+        r"<d x i32*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i64\*> .*",
-        "<d x i64*> operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i64\*> .*",
+        r"<d x i64*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i128\*> .*",
-        "<d x i128*> operation",
-        "<d x int*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i128\*> .*",
+        r"<d x i128*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x x86_fp80\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x x86_fp80\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x float\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x float\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x double\*> .*",
-        "<d x double*> operation",
-        "<d x floating point*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x double\*> .*",
+        r"<d x double*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x \{ .* \}\*> .*",
-        "<d x \{ .* \}*> operation",
-        "<d x \{ .* \}*> operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x \{ .* \}\*> .*",
+        r"<d x \{ .* \}*> operation",
+        r"<d x \{ .* \}*> operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i1>\* .*",
-        "<d x i1>*  operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i1>\* .*",
+        r"<d x i1>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i2>\* .*",
-        "<d x i2>*  operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i2>\* .*",
+        r"<d x i2>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i4>\* .*",
-        "<d x i4>*  operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i4>\* .*",
+        r"<d x i4>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i8>\* .*",
-        "<d x i8>*  operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i8>\* .*",
+        r"<d x i8>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i16>\* .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i16>\* .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i32>\* .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i32>\* .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i64>\* .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i64>\* .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x i128>\* .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x i128>\* .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x x86_fp80>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x x86_fp80>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x float>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x float>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x double>\* .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x double>\* .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x \{ .* \}\*?>\* .*",
-        "<d x struct>* operation",
-        "<d x \{ .* \}>* operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x \{ .* \}\*?>\* .*",
+        r"<d x struct>* operation",
+        r"<d x \{ .* \}>* operation",
     ],
     [
-        "store " + any_of(opt_load) + "?<\d+ x void \(.*",
-        "<d x function>* operation",
-        "<d x function operation",
+        r"store " + any_of(opt_load) + r"?<\d+ x void \(.*",
+        r"<d x function>* operation",
+        r"<d x function operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i1\] .*",
-        "[d x i1]  operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i1\] .*",
+        r"[d x i1]  operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i2\] .*",
-        "[d x i2]  operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i2\] .*",
+        r"[d x i2]  operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i4\] .*",
-        "[d x i4]  operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i4\] .*",
+        r"[d x i4]  operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i8\] .*",
-        "[d x i8]  operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i8\] .*",
+        r"[d x i8]  operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i16\] .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i16\] .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i32\] .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i32\] .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i64\] .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i64\] .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x i128\] .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x i128\] .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x x86_fp80\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x x86_fp80\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x float\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x float\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x double\] .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x double\] .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "store " + any_of(opt_load) + "?\[\d+ x \{ .* \}\] .*",
-        "[d x structure] operation",
-        "[d x structure] operation",
+        r"store " + any_of(opt_load) + r"?\[\d+ x \{ .* \}\] .*",
+        r"[d x structure] operation",
+        r"[d x structure] operation",
     ],
-    ["declare (noalias |nonnull )*void .*", "void operation", "void operation"],
-    ["declare (noalias |nonnull )*i1 .*", "i1  operation", "int operation"],
-    ["declare (noalias |nonnull )*i2 .*", "i2  operation", "int operation"],
-    ["declare (noalias |nonnull )*i4 .*", "i4  operation", "int operation"],
-    ["declare (noalias |nonnull )*i8 .*", "i8  operation", "int operation"],
-    ["declare (noalias |nonnull )*i16 .*", "i16 operation", "int operation"],
-    ["declare (noalias |nonnull )*i32 .*", "i32 operation", "int operation"],
-    ["declare (noalias |nonnull )*i64 .*", "i64 operation", "int operation"],
-    ["declare (noalias |nonnull )*i8\* .*", "i8*  operation", "int* operation"],
-    ["declare (noalias |nonnull )*i16\* .*", "i16* operation", "int* operation"],
-    ["declare (noalias |nonnull )*i32\* .*", "i32* operation", "int* operation"],
-    ["declare (noalias |nonnull )*i64\* .*", "i64* operation", "int* operation"],
+    [r"declare (noalias |nonnull )*void .*", "void operation", "void operation"],
+    [r"declare (noalias |nonnull )*i1 .*", "i1  operation", "int operation"],
+    [r"declare (noalias |nonnull )*i2 .*", "i2  operation", "int operation"],
+    [r"declare (noalias |nonnull )*i4 .*", "i4  operation", "int operation"],
+    [r"declare (noalias |nonnull )*i8 .*", "i8  operation", "int operation"],
+    [r"declare (noalias |nonnull )*i16 .*", "i16 operation", "int operation"],
+    [r"declare (noalias |nonnull )*i32 .*", "i32 operation", "int operation"],
+    [r"declare (noalias |nonnull )*i64 .*", "i64 operation", "int operation"],
+    [r"declare (noalias |nonnull )*i8\* .*", "i8*  operation", "int* operation"],
+    [r"declare (noalias |nonnull )*i16\* .*", "i16* operation", "int* operation"],
+    [r"declare (noalias |nonnull )*i32\* .*", "i32* operation", "int* operation"],
+    [r"declare (noalias |nonnull )*i64\* .*", "i64* operation", "int* operation"],
     [
-        "declare (noalias |nonnull )*x86_fp80 .*",
-        "float  operation",
-        "floating point operation",
+        r"declare (noalias |nonnull )*x86_fp80 .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "declare (noalias |nonnull )*float .*",
-        "float  operation",
-        "floating point operation",
+        r"declare (noalias |nonnull )*float .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "declare (noalias |nonnull )*double .*",
-        "double operation",
-        "floating point operation",
+        r"declare (noalias |nonnull )*double .*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "declare (noalias |nonnull )*x86_fp80\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"declare (noalias |nonnull )*x86_fp80\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "declare (noalias |nonnull )*float\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"declare (noalias |nonnull )*float\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "declare (noalias |nonnull )*double\* .*",
-        "double* operation",
-        "floating point* operation",
+        r"declare (noalias |nonnull )*double\* .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     ['declare (noalias |nonnull )*%".*', "struct/class op", "struct/class op"],
-    ["declare (noalias |nonnull )*<%.*", "struct/class op", "struct/class op"],
-    ["declare (noalias |nonnull )*<?{.*", "struct/class op", "struct/class op"],
+    [r"declare (noalias |nonnull )*<%.*", "struct/class op", "struct/class op"],
+    [r"declare (noalias |nonnull )*<?{.*", "struct/class op", "struct/class op"],
     [
-        "declare (noalias |nonnull )*opaque.*",
-        "struct/class op",
-        "struct/class op",
+        r"declare (noalias |nonnull )*opaque.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"declare (noalias |nonnull )*<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"declare (noalias |nonnull )*<\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"declare (noalias |nonnull )*<\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"declare (noalias |nonnull )*<\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i1>\* .*",
-        "<d x i1>*  operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i1>\* .*",
+        r"<d x i1>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i2>\* .*",
-        "<d x i2>*  operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i2>\* .*",
+        r"<d x i2>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i4>\* .*",
-        "<d x i4>*  operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i4>\* .*",
+        r"<d x i4>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i8>\* .*",
-        "<d x i8>*  operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i8>\* .*",
+        r"<d x i8>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i16>\* .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i16>\* .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i32>\* .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i32>\* .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i64>\* .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i64>\* .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x i128>\* .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        r"declare (noalias |nonnull )*<\d+ x i128>\* .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x x86_fp80>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"declare (noalias |nonnull )*<\d+ x x86_fp80>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x float>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"declare (noalias |nonnull )*<\d+ x float>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "declare (noalias |nonnull )*<\d+ x double>\* .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        r"declare (noalias |nonnull )*<\d+ x double>\* .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i1\] .*",
-        "[d x i1]  operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i1\] .*",
+        r"[d x i1]  operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i2\] .*",
-        "[d x i2]  operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i2\] .*",
+        r"[d x i2]  operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i4\] .*",
-        "[d x i4]  operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i4\] .*",
+        r"[d x i4]  operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i8\] .*",
-        "[d x i8]  operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i8\] .*",
+        r"[d x i8]  operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i16\] .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i16\] .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i32\] .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i32\] .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i64\] .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i64\] .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x i128\] .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        r"declare (noalias |nonnull )*\[\d+ x i128\] .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x x86_fp80\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"declare (noalias |nonnull )*\[\d+ x x86_fp80\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x float\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"declare (noalias |nonnull )*\[\d+ x float\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "declare (noalias |nonnull )*\[\d+ x double\] .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
+        r"declare (noalias |nonnull )*\[\d+ x double\] .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+void .*",
-        "void operation",
-        "void operation",
+        r"define " + any_of(opt_define) + r"+void .*",
+        r"void operation",
+        r"void operation",
     ],
-    ["define " + any_of(opt_define) + "+i1 .*", "i1  operation", "int operation"],
-    ["define " + any_of(opt_define) + "+i2 .*", "i2  operation", "int operation"],
-    ["define " + any_of(opt_define) + "+i4 .*", "i4  operation", "int operation"],
-    ["define " + any_of(opt_define) + "+i8 .*", "i8  operation", "int operation"],
+    [r"define " + any_of(opt_define) + r"+i1 .*", "i1  operation", "int operation"],
+    [r"define " + any_of(opt_define) + r"+i2 .*", "i2  operation", "int operation"],
+    [r"define " + any_of(opt_define) + r"+i4 .*", "i4  operation", "int operation"],
+    [r"define " + any_of(opt_define) + r"+i8 .*", "i8  operation", "int operation"],
     [
-        "define " + any_of(opt_define) + "+i16 .*",
-        "i16 operation",
-        "int operation",
+        r"define " + any_of(opt_define) + r"+i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i32 .*",
-        "i32 operation",
-        "int operation",
+        r"define " + any_of(opt_define) + r"+i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i64 .*",
-        "i64 operation",
-        "int operation",
+        r"define " + any_of(opt_define) + r"+i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i128 .*",
-        "i128 operation",
-        "int operation",
+        r"define " + any_of(opt_define) + r"+i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i1\* .*",
-        "i1*  operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i1\* .*",
+        r"i1*  operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i2\* .*",
-        "i2*  operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i2\* .*",
+        r"i2*  operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i4\* .*",
-        "i4*  operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i4\* .*",
+        r"i4*  operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i8\* .*",
-        "i8*  operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i8\* .*",
+        r"i8*  operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i16\* .*",
-        "i16* operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i16\* .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i32\* .*",
-        "i32* operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i32\* .*",
+        r"i32* operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i64\* .*",
-        "i64* operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i64\* .*",
+        r"i64* operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+i128\* .*",
-        "i128* operation",
-        "int* operation",
+        r"define " + any_of(opt_define) + r"+i128\* .*",
+        r"i128* operation",
+        r"int* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+x86_fp80 .*",
-        "float  operation",
-        "floating point operation",
+        r"define " + any_of(opt_define) + r"+x86_fp80 .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "define " + any_of(opt_define) + "+float .*",
-        "float  operation",
-        "floating point operation",
+        r"define " + any_of(opt_define) + r"+float .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "define " + any_of(opt_define) + "+double .*",
-        "double operation",
-        "floating point operation",
+        r"define " + any_of(opt_define) + r"+double .*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "define " + any_of(opt_define) + "+x86_fp80\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"define " + any_of(opt_define) + r"+x86_fp80\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+float\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"define " + any_of(opt_define) + r"+float\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+double\* .*",
-        "double* operation",
-        "floating point* operation",
+        r"define " + any_of(opt_define) + r"+double\* .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     [
-        "define " + any_of(opt_define) + '+%".*',
-        "struct/class op",
-        "struct/class op",
+        r"define " + any_of(opt_define) + r'+%".*',
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "define " + any_of(opt_define) + "+<%.*",
-        "struct/class op",
-        "struct/class op",
+        r"define " + any_of(opt_define) + r"+<%.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "define " + any_of(opt_define) + "+<?{.*",
-        "struct/class op",
-        "struct/class op",
+        r"define " + any_of(opt_define) + r"+<?{.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "define " + any_of(opt_define) + "+opaque.*",
-        "struct/class op",
-        "struct/class op",
+        r"define " + any_of(opt_define) + r"+opaque.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i1>\* .*",
-        "<d x i1>*  operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i1>\* .*",
+        r"<d x i1>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i2>\* .*",
-        "<d x i2>*  operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i2>\* .*",
+        r"<d x i2>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i4>\* .*",
-        "<d x i4>*  operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i4>\* .*",
+        r"<d x i4>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i8>\* .*",
-        "<d x i8>*  operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i8>\* .*",
+        r"<d x i8>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i16>\* .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i16>\* .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i32>\* .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i32>\* .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i64>\* .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i64>\* .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x i128>\* .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x i128>\* .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x x86_fp80>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x x86_fp80>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x float>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x float>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+<\d+ x double>\* .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        r"define " + any_of(opt_define) + r"+<\d+ x double>\* .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i1\] .*",
-        "[d x i1]  operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i1\] .*",
+        r"[d x i1]  operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i2\] .*",
-        "[d x i2]  operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i2\] .*",
+        r"[d x i2]  operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i4\] .*",
-        "[d x i4]  operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i4\] .*",
+        r"[d x i4]  operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i8\] .*",
-        "[d x i8]  operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i8\] .*",
+        r"[d x i8]  operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i16\] .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i16\] .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i32\] .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i32\] .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i64\] .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i64\] .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x i128\] .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x i128\] .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x x86_fp80\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x x86_fp80\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x float\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x float\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "define " + any_of(opt_define) + "+\[\d+ x double\] .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
+        r"define " + any_of(opt_define) + r"+\[\d+ x double\] .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i1\* .*",
-        "i1*  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i1\* .*",
+        r"i1*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i2\* .*",
-        "i2*  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i2\* .*",
+        r"i2*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i4\* .*",
-        "i4*  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i4\* .*",
+        r"i4*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i8\* .*",
-        "i8*  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i8\* .*",
+        r"i8*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i16\* .*",
-        "i16* operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i16\* .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i32\* .*",
-        "i32* operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i32\* .*",
+        r"i32* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i64\* .*",
-        "i64* operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i64\* .*",
+        r"i64* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i128\* .*",
-        "i128* operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i128\* .*",
+        r"i128* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i1\*\* .*",
-        "i1**  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i1\*\* .*",
+        r"i1**  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i2\*\* .*",
-        "i2**  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i2\*\* .*",
+        r"i2**  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i4\*\* .*",
-        "i4**  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i4\*\* .*",
+        r"i4**  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i8\*\* .*",
-        "i8**  operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*i8\*\* .*",
+        r"i8**  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i16\*\* .*",
-        "i16** operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call "
+        + any_of(opt_invoke)
+        + r"*i16\*\* .*",
+        r"i16** operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i32\*\* .*",
-        "i32** operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call "
+        + any_of(opt_invoke)
+        + r"*i32\*\* .*",
+        r"i32** operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i64\*\* .*",
-        "i64** operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call "
+        + any_of(opt_invoke)
+        + r"*i64\*\* .*",
+        r"i64** operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*i128\*\* .*",
-        "i128** operation",
-        "int* operation",
+        r"<%ID> = (tail |musttail |notail )?call "
+        + any_of(opt_invoke)
+        + r"*i128\*\* .*",
+        r"i128** operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*x86_fp80 .*",
-        "float operation",
-        "floating point operation",
+        r"<%ID> = (tail |musttail |notail )?call "
+        + any_of(opt_invoke)
+        + r"*x86_fp80 .*",
+        r"float operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*float .*",
-        "float operation",
-        "floating point operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*float .*",
+        r"float operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*double .*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*double .*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*x86_fp80\* .*",
-        "float* operation",
-        "floating point* operation",
+        + r"*x86_fp80\* .*",
+        r"float* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*float\* .*",
-        "float* operation",
-        "floating point* operation",
+        r"<%ID> = (tail |musttail |notail )?call "
+        + any_of(opt_invoke)
+        + r"*float\* .*",
+        r"float* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*double\* .*",
-        "double* operation",
-        "floating point* operation",
+        r"<%ID> = (tail |musttail |notail )?call "
+        + any_of(opt_invoke)
+        + r"*double\* .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*x86_fp80\*\* .*",
-        "float** operation",
-        "floating point* operation",
+        + r"*x86_fp80\*\* .*",
+        r"float** operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*float\*\* .*",
-        "float** operation",
-        "floating point* operation",
+        + r"*float\*\* .*",
+        r"float** operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*double\*\* .*",
-        "double** operation",
-        "floating point* operation",
+        + r"*double\*\* .*",
+        r"double** operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + '*%".*',
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r'*%".*',
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*<%.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*<%.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*<?{.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*<?{.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + "*opaque.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = (tail |musttail |notail )?call " + any_of(opt_invoke) + r"*opaque.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        + r"*<\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        + r"*<\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        + r"*<\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        + r"*<\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        + r"*<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        + r"*<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        + r"*<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        + r"*<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        + r"*<\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        + r"*<\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        + r"*<\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i1>\* .*",
-        "<d x i1>*  operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i1>\* .*",
+        r"<d x i1>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i2>\* .*",
-        "<d x i2>*  operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i2>\* .*",
+        r"<d x i2>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i4>\* .*",
-        "<d x i4>*  operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i4>\* .*",
+        r"<d x i4>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i8>\* .*",
-        "<d x i8>*  operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i8>\* .*",
+        r"<d x i8>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i16>\* .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i16>\* .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i32>\* .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i32>\* .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i64>\* .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i64>\* .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x i128>\* .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        + r"*<\d+ x i128>\* .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x x86_fp80>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        + r"*<\d+ x x86_fp80>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x float>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        + r"*<\d+ x float>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*<\d+ x double>\* .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        + r"*<\d+ x double>\* .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i1\] .*",
-        "[d x i1]  operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i1\] .*",
+        r"[d x i1]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i2\] .*",
-        "[d x i2]  operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i2\] .*",
+        r"[d x i2]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i4\] .*",
-        "[d x i4]  operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i4\] .*",
+        r"[d x i4]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i8\] .*",
-        "[d x i8]  operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i8\] .*",
+        r"[d x i8]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i16\] .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i16\] .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i32\] .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i32\] .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i64\] .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i64\] .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x i128\] .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        + r"*\[\d+ x i128\] .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x x86_fp80\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        + r"*\[\d+ x x86_fp80\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x float\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        + r"*\[\d+ x float\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = (tail |musttail |notail )?call "
+        r"<%ID> = (tail |musttail |notail )?call "
         + any_of(opt_invoke)
-        + "*\[\d+ x double\] .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
-    ],
-    ["ret i1 .*", "i1  operation", "int operation"],
-    ["ret i2 .*", "i2  operation", "int operation"],
-    ["ret i4 .*", "i4  operation", "int operation"],
-    ["ret i8 .*", "i8  operation", "int operation"],
-    ["ret i16 .*", "i16 operation", "int operation"],
-    ["ret i32 .*", "i32 operation", "int operation"],
-    ["ret i64 .*", "i64 operation", "int operation"],
-    ["ret i128 .*", "i128 operation", "int operation"],
-    ["ret i1\* .*", "i1*  operation", "int* operation"],
-    ["ret i2\* .*", "i2*  operation", "int* operation"],
-    ["ret i4\* .*", "i4*  operation", "int* operation"],
-    ["ret i8\* .*", "i8*  operation", "int* operation"],
-    ["ret i16\* .*", "i16* operation", "int* operation"],
-    ["ret i32\* .*", "i32* operation", "int* operation"],
-    ["ret i64\* .*", "i64* operation", "int* operation"],
-    ["ret i128\* .*", "i128* operation", "int* operation"],
-    ["ret x86_fp80 .*", "x86_fp80  operation", "floating point operation"],
-    ["ret float .*", "float  operation", "floating point operation"],
-    ["ret double .*", "double operation", "floating point operation"],
-    ["ret x86_fp80\* .*", "x86_fp80*  operation", "floating point* operation"],
-    ["ret float\* .*", "float*  operation", "floating point* operation"],
-    ["ret double\* .*", "double* operation", "floating point* operation"],
+        + r"*\[\d+ x double\] .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
+    ],
+    [r"ret i1 .*", "i1  operation", "int operation"],
+    [r"ret i2 .*", "i2  operation", "int operation"],
+    [r"ret i4 .*", "i4  operation", "int operation"],
+    [r"ret i8 .*", "i8  operation", "int operation"],
+    [r"ret i16 .*", "i16 operation", "int operation"],
+    [r"ret i32 .*", "i32 operation", "int operation"],
+    [r"ret i64 .*", "i64 operation", "int operation"],
+    [r"ret i128 .*", "i128 operation", "int operation"],
+    [r"ret i1\* .*", "i1*  operation", "int* operation"],
+    [r"ret i2\* .*", "i2*  operation", "int* operation"],
+    [r"ret i4\* .*", "i4*  operation", "int* operation"],
+    [r"ret i8\* .*", "i8*  operation", "int* operation"],
+    [r"ret i16\* .*", "i16* operation", "int* operation"],
+    [r"ret i32\* .*", "i32* operation", "int* operation"],
+    [r"ret i64\* .*", "i64* operation", "int* operation"],
+    [r"ret i128\* .*", "i128* operation", "int* operation"],
+    [r"ret x86_fp80 .*", "x86_fp80  operation", "floating point operation"],
+    [r"ret float .*", "float  operation", "floating point operation"],
+    [r"ret double .*", "double operation", "floating point operation"],
+    [r"ret x86_fp80\* .*", "x86_fp80*  operation", "floating point* operation"],
+    [r"ret float\* .*", "float*  operation", "floating point* operation"],
+    [r"ret double\* .*", "double* operation", "floating point* operation"],
     ['ret %".*', "struct/class op", "struct/class op"],
-    ["ret <%.*", "struct/class op", "struct/class op"],
-    ["ret <?{.*", "struct/class op", "struct/class op"],
-    ["ret opaque.*", "struct/class op", "struct/class op"],
-    ["ret <\d+ x i1> .*", "<d x i1>  operation", "<d x int> operation"],
-    ["ret <\d+ x i2> .*", "<d x i2>  operation", "<d x int> operation"],
-    ["ret <\d+ x i4> .*", "<d x i4>  operation", "<d x int> operation"],
-    ["ret <\d+ x i8> .*", "<d x i8>  operation", "<d x int> operation"],
-    ["ret <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
-    ["ret <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
-    ["ret <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
-    ["ret <\d+ x i128> .*", "<d x i128> operation", "<d x int> operation"],
-    [
-        "ret <\d+ x x86_fp80> .*",
-        "<d x x86_fp80> operation",
-        "<d x floating point> operation",
-    ],
-    [
-        "ret <\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
-    ],
-    [
-        "ret <\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
-    ],
-    ["ret <\d+ x i1>\* .*", "<d x i1>*  operation", "<d x int>* operation"],
-    ["ret <\d+ x i2>\* .*", "<d x i2>*  operation", "<d x int>* operation"],
-    ["ret <\d+ x i4>\* .*", "<d x i4>*  operation", "<d x int>* operation"],
-    ["ret <\d+ x i8>\* .*", "<d x i8>*  operation", "<d x int>* operation"],
-    ["ret <\d+ x i16>\* .*", "<d x i16>* operation", "<d x int>* operation"],
-    ["ret <\d+ x i32>\* .*", "<d x i32>* operation", "<d x int>* operation"],
-    ["ret <\d+ x i64>\* .*", "<d x i64>* operation", "<d x int>* operation"],
-    ["ret <\d+ x i128>\* .*", "<d x i128>* operation", "<d x int>* operation"],
-    [
-        "ret <\d+ x x86_fp80>\* .*",
-        "<d x x86_fp80>* operation",
-        "<d x floating point>* operation",
-    ],
-    [
-        "ret <\d+ x float>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
-    ],
-    [
-        "ret <\d+ x double>\* .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
-    ],
-    ["ret \[\d+ x i1\] .*", "[d x i1]  operation", "[d x int] operation"],
-    ["ret \[\d+ x i2\] .*", "[d x i2]  operation", "[d x int] operation"],
-    ["ret \[\d+ x i4\] .*", "[d x i4]  operation", "[d x int] operation"],
-    ["ret \[\d+ x i8\] .*", "[d x i8]  operation", "[d x int] operation"],
-    ["ret \[\d+ x i16\] .*", "[d x i16] operation", "[d x int] operation"],
-    ["ret \[\d+ x i32\] .*", "[d x i32] operation", "[d x int] operation"],
-    ["ret \[\d+ x i64\] .*", "[d x i64] operation", "[d x int] operation"],
-    ["ret \[\d+ x i128\] .*", "[d x i128] operation", "[d x int] operation"],
-    [
-        "ret \[\d+ x x86_fp80\] .*",
-        "[d x x86_fp80] operation",
-        "[d x floating point] operation",
-    ],
-    [
-        "ret \[\d+ x float\] .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
-    ],
-    [
-        "ret \[\d+ x double\] .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
-    ],
-    ["<%ID> = and i1 .*", "i1  operation", "int operation"],
-    ["<%ID> = and <\d+ x i1> .*", "<d x i1> operation", "<d x int> operation"],
-    ["<%ID> = and i2 .*", "i2  operation", "int operation"],
-    ["<%ID> = and <\d+ x i2> .*", "<d x i2> operation", "<d x int> operation"],
-    ["<%ID> = and i4 .*", "i4  operation", "int operation"],
-    ["<%ID> = and <\d+ x i4> .*", "<d x i4> operation", "<d x int> operation"],
-    ["<%ID> = and i8 .*", "i8  operation", "int operation"],
-    ["<%ID> = and <\d+ x i8> .*", "<d x i8> operation", "<d x int> operation"],
-    ["<%ID> = and i16 .*", "i16 operation", "int operation"],
-    ["<%ID> = and <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
-    ["<%ID> = and i24 .*", "i24 operation", "int operation"],
-    ["<%ID> = and <\d+ x i24> .*", "<d x i24> operation", "<d x int> operation"],
-    ["<%ID> = and i32 .*", "i32 operation", "int operation"],
-    ["<%ID> = and <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
-    ["<%ID> = and i40 .*", "i40 operation", "int operation"],
-    ["<%ID> = and <\d+ x i40> .*", "<d x i40> operation", "<d x int> operation"],
-    ["<%ID> = and i64 .*", "i64 operation", "int operation"],
-    ["<%ID> = and <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
-    ["<%ID> = and i128 .*", "i128 operation", "int operation"],
-    [
-        "<%ID> = and <\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
-    ],
-    ["<%ID> = or i1 .*", "i1  operation", "int operation"],
-    ["<%ID> = or <\d+ x i1> .*", "<d x i1> operation", "<d x int> operation"],
-    ["<%ID> = or i2 .*", "i2  operation", "int operation"],
-    ["<%ID> = or <\d+ x i2> .*", "<d x i2> operation", "<d x int> operation"],
-    ["<%ID> = or i4 .*", "i4  operation", "int operation"],
-    ["<%ID> = or <\d+ x i4> .*", "<d x i4> operation", "<d x int> operation"],
-    ["<%ID> = or i8 .*", "i8  operation", "int operation"],
-    ["<%ID> = or <\d+ x i8> .*", "<d x i8> operation", "<d x int> operation"],
-    ["<%ID> = or i16 .*", "i16 operation", "int operation"],
-    ["<%ID> = or <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
-    ["<%ID> = or i24 .*", "i24 operation", "int operation"],
-    ["<%ID> = or <\d+ x i24> .*", "<d x i24> operation", "<d x int> operation"],
-    ["<%ID> = or i32 .*", "i32 operation", "int operation"],
-    ["<%ID> = or <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
-    ["<%ID> = or i40 .*", "i40 operation", "int operation"],
-    ["<%ID> = or <\d+ x i40> .*", "<d x i40> operation", "<d x int> operation"],
-    ["<%ID> = or i64 .*", "i64 operation", "int operation"],
-    ["<%ID> = or <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
-    ["<%ID> = or i128 .*", "i128 operation", "int operation"],
-    ["<%ID> = or <\d+ x i128> .*", "<d x i128> operation", "<d x int> operation"],
-    ["<%ID> = xor i1 .*", "i1  operation", "int operation"],
-    ["<%ID> = xor <\d+ x i1>.*", "<d x i1> operation", "<d x int> operation"],
-    ["<%ID> = xor i4 .*", "i4  operation", "int operation"],
-    ["<%ID> = xor <\d+ x i2>.*", "<d x i2> operation", "<d x int> operation"],
-    ["<%ID> = xor i2 .*", "i2  operation", "int operation"],
-    ["<%ID> = xor <\d+ x i4>.*", "<d x i4> operation", "<d x int> operation"],
-    ["<%ID> = xor i8 .*", "i8  operation", "int operation"],
-    ["<%ID> = xor <\d+ x i8>.*", "<d x i8> operation", "<d x int> operation"],
-    ["<%ID> = xor i16 .*", "i16 operation", "int operation"],
-    ["<%ID> = xor <\d+ x i16>.*", "<d x i16> operation", "<d x int> operation"],
-    ["<%ID> = xor i24 .*", "i16 operation", "int operation"],
-    ["<%ID> = xor <\d+ x i24>.*", "<d x i16> operation", "<d x int> operation"],
-    ["<%ID> = xor i32 .*", "i32 operation", "int operation"],
-    ["<%ID> = xor <\d+ x i32>.*", "<d x i32> operation", "<d x int> operation"],
-    ["<%ID> = xor i40 .*", "i40 operation", "int operation"],
-    ["<%ID> = xor <\d+ x i40>.*", "<d x i40> operation", "<d x int> operation"],
-    ["<%ID> = xor i64 .*", "i64 operation", "int operation"],
-    ["<%ID> = xor <\d+ x i64>.*", "<d x i64> operation", "<d x int> operation"],
-    ["<%ID> = xor i128 .*", "i128 operation", "int operation"],
-    ["<%ID> = xor <\d+ x i128>.*", "<d x i128> operation", "<d x int> operation"],
+    [r"ret <%.*", "struct/class op", "struct/class op"],
+    [r"ret <?{.*", "struct/class op", "struct/class op"],
+    [r"ret opaque.*", "struct/class op", "struct/class op"],
+    [r"ret <\d+ x i1> .*", "<d x i1>  operation", "<d x int> operation"],
+    [r"ret <\d+ x i2> .*", "<d x i2>  operation", "<d x int> operation"],
+    [r"ret <\d+ x i4> .*", "<d x i4>  operation", "<d x int> operation"],
+    [r"ret <\d+ x i8> .*", "<d x i8>  operation", "<d x int> operation"],
+    [r"ret <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
+    [r"ret <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
+    [r"ret <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
+    [r"ret <\d+ x i128> .*", "<d x i128> operation", "<d x int> operation"],
+    [
+        r"ret <\d+ x x86_fp80> .*",
+        r"<d x x86_fp80> operation",
+        r"<d x floating point> operation",
+    ],
+    [
+        r"ret <\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
+    ],
+    [
+        r"ret <\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
+    ],
+    [r"ret <\d+ x i1>\* .*", "<d x i1>*  operation", "<d x int>* operation"],
+    [r"ret <\d+ x i2>\* .*", "<d x i2>*  operation", "<d x int>* operation"],
+    [r"ret <\d+ x i4>\* .*", "<d x i4>*  operation", "<d x int>* operation"],
+    [r"ret <\d+ x i8>\* .*", "<d x i8>*  operation", "<d x int>* operation"],
+    [r"ret <\d+ x i16>\* .*", "<d x i16>* operation", "<d x int>* operation"],
+    [r"ret <\d+ x i32>\* .*", "<d x i32>* operation", "<d x int>* operation"],
+    [r"ret <\d+ x i64>\* .*", "<d x i64>* operation", "<d x int>* operation"],
+    [r"ret <\d+ x i128>\* .*", "<d x i128>* operation", "<d x int>* operation"],
+    [
+        r"ret <\d+ x x86_fp80>\* .*",
+        r"<d x x86_fp80>* operation",
+        r"<d x floating point>* operation",
+    ],
+    [
+        r"ret <\d+ x float>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
+    ],
+    [
+        r"ret <\d+ x double>\* .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
+    ],
+    [r"ret \[\d+ x i1\] .*", "[d x i1]  operation", "[d x int] operation"],
+    [r"ret \[\d+ x i2\] .*", "[d x i2]  operation", "[d x int] operation"],
+    [r"ret \[\d+ x i4\] .*", "[d x i4]  operation", "[d x int] operation"],
+    [r"ret \[\d+ x i8\] .*", "[d x i8]  operation", "[d x int] operation"],
+    [r"ret \[\d+ x i16\] .*", "[d x i16] operation", "[d x int] operation"],
+    [r"ret \[\d+ x i32\] .*", "[d x i32] operation", "[d x int] operation"],
+    [r"ret \[\d+ x i64\] .*", "[d x i64] operation", "[d x int] operation"],
+    [r"ret \[\d+ x i128\] .*", "[d x i128] operation", "[d x int] operation"],
+    [
+        r"ret \[\d+ x x86_fp80\] .*",
+        r"[d x x86_fp80] operation",
+        r"[d x floating point] operation",
+    ],
+    [
+        r"ret \[\d+ x float\] .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
+    ],
+    [
+        r"ret \[\d+ x double\] .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
+    ],
+    [r"<%ID> = and i1 .*", "i1  operation", "int operation"],
+    [r"<%ID> = and <\d+ x i1> .*", "<d x i1> operation", "<d x int> operation"],
+    [r"<%ID> = and i2 .*", "i2  operation", "int operation"],
+    [r"<%ID> = and <\d+ x i2> .*", "<d x i2> operation", "<d x int> operation"],
+    [r"<%ID> = and i4 .*", "i4  operation", "int operation"],
+    [r"<%ID> = and <\d+ x i4> .*", "<d x i4> operation", "<d x int> operation"],
+    [r"<%ID> = and i8 .*", "i8  operation", "int operation"],
+    [r"<%ID> = and <\d+ x i8> .*", "<d x i8> operation", "<d x int> operation"],
+    [r"<%ID> = and i16 .*", "i16 operation", "int operation"],
+    [r"<%ID> = and <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
+    [r"<%ID> = and i24 .*", "i24 operation", "int operation"],
+    [r"<%ID> = and <\d+ x i24> .*", "<d x i24> operation", "<d x int> operation"],
+    [r"<%ID> = and i32 .*", "i32 operation", "int operation"],
+    [r"<%ID> = and <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
+    [r"<%ID> = and i40 .*", "i40 operation", "int operation"],
+    [r"<%ID> = and <\d+ x i40> .*", "<d x i40> operation", "<d x int> operation"],
+    [r"<%ID> = and i64 .*", "i64 operation", "int operation"],
+    [r"<%ID> = and <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
+    [r"<%ID> = and i128 .*", "i128 operation", "int operation"],
+    [
+        r"<%ID> = and <\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
+    ],
+    [r"<%ID> = or i1 .*", "i1  operation", "int operation"],
+    [r"<%ID> = or <\d+ x i1> .*", "<d x i1> operation", "<d x int> operation"],
+    [r"<%ID> = or i2 .*", "i2  operation", "int operation"],
+    [r"<%ID> = or <\d+ x i2> .*", "<d x i2> operation", "<d x int> operation"],
+    [r"<%ID> = or i4 .*", "i4  operation", "int operation"],
+    [r"<%ID> = or <\d+ x i4> .*", "<d x i4> operation", "<d x int> operation"],
+    [r"<%ID> = or i8 .*", "i8  operation", "int operation"],
+    [r"<%ID> = or <\d+ x i8> .*", "<d x i8> operation", "<d x int> operation"],
+    [r"<%ID> = or i16 .*", "i16 operation", "int operation"],
+    [r"<%ID> = or <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
+    [r"<%ID> = or i24 .*", "i24 operation", "int operation"],
+    [r"<%ID> = or <\d+ x i24> .*", "<d x i24> operation", "<d x int> operation"],
+    [r"<%ID> = or i32 .*", "i32 operation", "int operation"],
+    [r"<%ID> = or <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
+    [r"<%ID> = or i40 .*", "i40 operation", "int operation"],
+    [r"<%ID> = or <\d+ x i40> .*", "<d x i40> operation", "<d x int> operation"],
+    [r"<%ID> = or i64 .*", "i64 operation", "int operation"],
+    [r"<%ID> = or <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
+    [r"<%ID> = or i128 .*", "i128 operation", "int operation"],
+    [r"<%ID> = or <\d+ x i128> .*", "<d x i128> operation", "<d x int> operation"],
+    [r"<%ID> = xor i1 .*", "i1  operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i1>.*", "<d x i1> operation", "<d x int> operation"],
+    [r"<%ID> = xor i4 .*", "i4  operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i2>.*", "<d x i2> operation", "<d x int> operation"],
+    [r"<%ID> = xor i2 .*", "i2  operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i4>.*", "<d x i4> operation", "<d x int> operation"],
+    [r"<%ID> = xor i8 .*", "i8  operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i8>.*", "<d x i8> operation", "<d x int> operation"],
+    [r"<%ID> = xor i16 .*", "i16 operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i16>.*", "<d x i16> operation", "<d x int> operation"],
+    [r"<%ID> = xor i24 .*", "i16 operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i24>.*", "<d x i16> operation", "<d x int> operation"],
+    [r"<%ID> = xor i32 .*", "i32 operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i32>.*", "<d x i32> operation", "<d x int> operation"],
+    [r"<%ID> = xor i40 .*", "i40 operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i40>.*", "<d x i40> operation", "<d x int> operation"],
+    [r"<%ID> = xor i64 .*", "i64 operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i64>.*", "<d x i64> operation", "<d x int> operation"],
+    [r"<%ID> = xor i128 .*", "i128 operation", "int operation"],
+    [r"<%ID> = xor <\d+ x i128>.*", "<d x i128> operation", "<d x int> operation"],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i1> .*",
-        "<d x i1> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i1> .*",
+        r"<d x i1> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i2> .*",
-        "<d x i2> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i2> .*",
+        r"<d x i2> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i4 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i4 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i4> .*",
-        "<d x i4> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i4> .*",
+        r"<d x i4> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i8> .*",
-        "<d x i8> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i8> .*",
+        r"<d x i8> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i40 .*",
-        "i40 operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i40 .*",
+        r"i40 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i40> .*",
-        "<d x i40> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i40> .*",
+        r"<d x i40> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?i256 .*",
-        "i256 operation",
-        "int operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?i256 .*",
+        r"i256 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = shl " + any_of(opt_addsubmul) + "?<\d+ x i256> .*",
-        "<d x i256> operation",
-        "<d x int> operation",
+        r"<%ID> = shl " + any_of(opt_addsubmul) + r"?<\d+ x i256> .*",
+        r"<d x i256> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i1 .*",
-        "i1 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i1 .*",
+        r"i1 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i1> .*",
-        "<d x i1> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i1> .*",
+        r"<d x i1> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i2 .*",
-        "i2 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i2 .*",
+        r"i2 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i2> .*",
-        "<d x i2> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i2> .*",
+        r"<d x i2> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i4> .*",
-        "<d x i4> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i4> .*",
+        r"<d x i4> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i8> .*",
-        "<d x i8> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i8> .*",
+        r"<d x i8> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i40 .*",
-        "i40 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i40 .*",
+        r"i40 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i40> .*",
-        "<d x i40> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i40> .*",
+        r"<d x i40> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?i256 .*",
-        "i256 operation",
-        "int operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?i256 .*",
+        r"i256 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = ashr " + any_of(opt_usdiv) + "?<\d+ x i256> .*",
-        "<d x i256> operation",
-        "<d x int> operation",
+        r"<%ID> = ashr " + any_of(opt_usdiv) + r"?<\d+ x i256> .*",
+        r"<d x i256> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i1> .*",
-        "<d x i1> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i1> .*",
+        r"<d x i1> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i2> .*",
-        "<d x i2> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i2> .*",
+        r"<d x i2> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i4> .*",
-        "<d x i4> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i4> .*",
+        r"<d x i4> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i8> .*",
-        "<d x i8> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i8> .*",
+        r"<d x i8> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i24 .*",
-        "i24 operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i24 .*",
+        r"i24 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i24> .*",
-        "<d x i24> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i24> .*",
+        r"<d x i24> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i40 .*",
-        "i40 operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i40 .*",
+        r"i40 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i40> .*",
-        "<d x i40> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i40> .*",
+        r"<d x i40> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?i256 .*",
-        "i256 operation",
-        "int operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?i256 .*",
+        r"i256 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = lshr " + any_of(opt_usdiv) + "?<\d+ x i256> .*",
-        "<d x i256> operation",
-        "<d x int> operation",
+        r"<%ID> = lshr " + any_of(opt_usdiv) + r"?<\d+ x i256> .*",
+        r"<d x i256> operation",
+        r"<d x int> operation",
     ],
-    ["<%ID> = phi i1 .*", "i1  operation", "int operation"],
-    ["<%ID> = phi <\d+ x i1> .*", "<d x i1> operation", "<d x int> operation"],
+    [r"<%ID> = phi i1 .*", "i1  operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i1> .*", "<d x i1> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i1\*> .*",
-        "<d x i1*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i1\*> .*",
+        r"<d x i1*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i1>\* .*",
-        "<d x i1>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i1>\* .*",
+        r"<d x i1>* operation",
+        r"<d x int>* operation",
     ],
-    ["<%ID> = phi \[\d+ x i1\] .*", "[d x i1] operation", "[d x int] operation"],
+    [r"<%ID> = phi \[\d+ x i1\] .*", "[d x i1] operation", "[d x int] operation"],
     [
-        "<%ID> = phi \[\d+ x i1\]\* .*",
-        "[d x i1]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i1\]\* .*",
+        r"[d x i1]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i1\]\*\* .*",
-        "[d x i1]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i1\]\*\* .*",
+        r"[d x i1]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i1\]\*\*\* .*",
-        "[d x i1]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i1\]\*\*\* .*",
+        r"[d x i1]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i2 .*", "i2  operation", "int operation"],
-    ["<%ID> = phi <\d+ x i2> .*", "<d x i2> operation", "<d x int> operation"],
+    [r"<%ID> = phi i2 .*", "i2  operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i2> .*", "<d x i2> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i2\*> .*",
-        "<d x i2*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i2\*> .*",
+        r"<d x i2*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i2>\* .*",
-        "<d x i2>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i2>\* .*",
+        r"<d x i2>* operation",
+        r"<d x int>* operation",
     ],
-    ["<%ID> = phi \[\d+ x i2\] .*", "[d x i2] operation", "[d x int] operation"],
+    [r"<%ID> = phi \[\d+ x i2\] .*", "[d x i2] operation", "[d x int] operation"],
     [
-        "<%ID> = phi \[\d+ x i2\]\* .*",
-        "[d x i2]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i2\]\* .*",
+        r"[d x i2]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i2\]\*\* .*",
-        "[d x i2]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i2\]\*\* .*",
+        r"[d x i2]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i2\]\*\*\* .*",
-        "[d x i2]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i2\]\*\*\* .*",
+        r"[d x i2]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i4 .*", "i4  operation", "int operation"],
-    ["<%ID> = phi <\d+ x i4> .*", "<d x i4> operation", "<d x int> operation"],
+    [r"<%ID> = phi i4 .*", "i4  operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i4> .*", "<d x i4> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i4\*> .*",
-        "<d x i4*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i4\*> .*",
+        r"<d x i4*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i4>\* .*",
-        "<d x i4>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i4>\* .*",
+        r"<d x i4>* operation",
+        r"<d x int>* operation",
     ],
-    ["<%ID> = phi \[\d+ x i4\] .*", "[d x i4] operation", "[d x int] operation"],
+    [r"<%ID> = phi \[\d+ x i4\] .*", "[d x i4] operation", "[d x int] operation"],
     [
-        "<%ID> = phi \[\d+ x i4\]\* .*",
-        "[d x i4]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i4\]\* .*",
+        r"[d x i4]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i4\]\*\* .*",
-        "[d x i4]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i4\]\*\* .*",
+        r"[d x i4]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i4\]\*\*\* .*",
-        "[d x i4]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i4\]\*\*\* .*",
+        r"[d x i4]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i8 .*", "i8  operation", "int operation"],
-    ["<%ID> = phi <\d+ x i8> .*", "<d x i8> operation", "<d x int> operation"],
+    [r"<%ID> = phi i8 .*", "i8  operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i8> .*", "<d x i8> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i8\*> .*",
-        "<d x i8*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i8\*> .*",
+        r"<d x i8*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i8>\* .*",
-        "<d x i8>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i8>\* .*",
+        r"<d x i8>* operation",
+        r"<d x int>* operation",
     ],
-    ["<%ID> = phi \[\d+ x i8\] .*", "[d x i4] operation", "[d x int] operation"],
+    [r"<%ID> = phi \[\d+ x i8\] .*", "[d x i4] operation", "[d x int] operation"],
     [
-        "<%ID> = phi \[\d+ x i8\]\* .*",
-        "[d x i4]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i8\]\* .*",
+        r"[d x i4]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i8\]\*\* .*",
-        "[d x i4]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i8\]\*\* .*",
+        r"[d x i4]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i8\]\*\*\* .*",
-        "[d x i4]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i8\]\*\*\* .*",
+        r"[d x i4]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i16 .*", "i16 operation", "int operation"],
-    ["<%ID> = phi <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
+    [r"<%ID> = phi i16 .*", "i16 operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i16> .*", "<d x i16> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i16\*> .*",
-        "<d x i16*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i16\*> .*",
+        r"<d x i16*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i16>\* .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i16>\* .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i16\] .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"<%ID> = phi \[\d+ x i16\] .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i16\]\* .*",
-        "[d x i16]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i16\]\* .*",
+        r"[d x i16]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i16\]\*\* .*",
-        "[d x i16]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i16\]\*\* .*",
+        r"[d x i16]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i16\]\*\*\* .*",
-        "[d x i16]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i16\]\*\*\* .*",
+        r"[d x i16]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i32 .*", "i32 operation", "int operation"],
-    ["<%ID> = phi <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
+    [r"<%ID> = phi i32 .*", "i32 operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i32> .*", "<d x i32> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i32\*> .*",
-        "<d x i32*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i32\*> .*",
+        r"<d x i32*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i32>\* .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i32>\* .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i32\] .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        r"<%ID> = phi \[\d+ x i32\] .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i32\]\* .*",
-        "[d x i32]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i32\]\* .*",
+        r"[d x i32]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i32\]\*\* .*",
-        "[d x i32]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i32\]\*\* .*",
+        r"[d x i32]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i32\]\*\*\* .*",
-        "[d x i32]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i32\]\*\*\* .*",
+        r"[d x i32]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i40 .*", "i32 operation", "int operation"],
-    ["<%ID> = phi <\d+ x i40> .*", "<d x i40> operation", "<d x int> operation"],
+    [r"<%ID> = phi i40 .*", "i32 operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i40> .*", "<d x i40> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i40\*> .*",
-        "<d x i40*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i40\*> .*",
+        r"<d x i40*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i40>\* .*",
-        "<d x i40>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i40>\* .*",
+        r"<d x i40>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i40\] .*",
-        "[d x i40] operation",
-        "[d x int] operation",
+        r"<%ID> = phi \[\d+ x i40\] .*",
+        r"[d x i40] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i40\]\* .*",
-        "[d x i40]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i40\]\* .*",
+        r"[d x i40]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i40\]\*\* .*",
-        "[d x i40]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i40\]\*\* .*",
+        r"[d x i40]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i40\]\*\*\* .*",
-        "[d x i40]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i40\]\*\*\* .*",
+        r"[d x i40]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i64 .*", "i64 operation", "int operation"],
-    ["<%ID> = phi <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
+    [r"<%ID> = phi i64 .*", "i64 operation", "int operation"],
+    [r"<%ID> = phi <\d+ x i64> .*", "<d x i64> operation", "<d x int> operation"],
     [
-        "<%ID> = phi <\d+ x i64\*> .*",
-        "<d x i64*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i64\*> .*",
+        r"<d x i64*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i64>\* .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i64>\* .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i64\] .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        r"<%ID> = phi \[\d+ x i64\] .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i64\]\* .*",
-        "[d x i64]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i64\]\* .*",
+        r"[d x i64]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i64\]\*\* .*",
-        "[d x i64]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i64\]\*\* .*",
+        r"[d x i64]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i64\]\*\*\* .*",
-        "[d x i64]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i64\]\*\*\* .*",
+        r"[d x i64]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i128 .*", "i128 operation", "int operation"],
+    [r"<%ID> = phi i128 .*", "i128 operation", "int operation"],
     [
-        "<%ID> = phi <\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = phi <\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i128\*> .*",
-        "<d x i128*> operation",
-        "<d x int*> operation",
+        r"<%ID> = phi <\d+ x i128\*> .*",
+        r"<d x i128*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x i128>\* .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        r"<%ID> = phi <\d+ x i128>\* .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i128\] .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        r"<%ID> = phi \[\d+ x i128\] .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i128\]\* .*",
-        "[d x i128]* operation",
-        "[d x int]* operation",
+        r"<%ID> = phi \[\d+ x i128\]\* .*",
+        r"[d x i128]* operation",
+        r"[d x int]* operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i126\]\*\* .*",
-        "[d x i128]** operation",
-        "[d x int]** operation",
+        r"<%ID> = phi \[\d+ x i126\]\*\* .*",
+        r"[d x i128]** operation",
+        r"[d x int]** operation",
     ],
     [
-        "<%ID> = phi \[\d+ x i128\]\*\*\* .*",
-        "[d x i128]*** operation",
-        "[d x int]*** operation",
+        r"<%ID> = phi \[\d+ x i128\]\*\*\* .*",
+        r"[d x i128]*** operation",
+        r"[d x int]*** operation",
     ],
-    ["<%ID> = phi i1\* .*", "i1*  operation", "int* operation"],
-    ["<%ID> = phi i2\* .*", "i2*  operation", "int* operation"],
-    ["<%ID> = phi i4\* .*", "i4*  operation", "int* operation"],
-    ["<%ID> = phi i8\* .*", "i8*  operation", "int* operation"],
-    ["<%ID> = phi i16\* .*", "i16*  operation", "int* operation"],
-    ["<%ID> = phi i32\* .*", "i32*  operation", "int* operation"],
-    ["<%ID> = phi i40\* .*", "i40*  operation", "int* operation"],
-    ["<%ID> = phi i64\* .*", "i64*  operation", "int* operation"],
-    ["<%ID> = phi i128\* .*", "i128*  operation", "int* operation"],
-    ["<%ID> = phi i1\*\* .*", "i1**  operation", "int** operation"],
-    ["<%ID> = phi i2\*\* .*", "i2**  operation", "int** operation"],
-    ["<%ID> = phi i4\*\* .*", "i4**  operation", "int** operation"],
-    ["<%ID> = phi i8\*\* .*", "i8**  operation", "int** operation"],
-    ["<%ID> = phi i16\*\* .*", "i16** operation", "int** operation"],
-    ["<%ID> = phi i32\*\* .*", "i32** operation", "int** operation"],
-    ["<%ID> = phi i40\*\* .*", "i40** operation", "int** operation"],
-    ["<%ID> = phi i64\*\* .*", "i64** operation", "int** operation"],
-    ["<%ID> = phi i128\*\* .*", "i128** operation", "int** operation"],
-    ["<%ID> = phi i1\*\*\* .*", "i1***  operation", "int*** operation"],
-    ["<%ID> = phi i2\*\*\* .*", "i2***  operation", "int*** operation"],
-    ["<%ID> = phi i4\*\*\* .*", "i4***  operation", "int*** operation"],
-    ["<%ID> = phi i8\*\*\* .*", "i8***  operation", "int*** operation"],
-    ["<%ID> = phi i16\*\*\* .*", "i16*** operation", "int*** operation"],
-    ["<%ID> = phi i32\*\*\* .*", "i32*** operation", "int*** operation"],
-    ["<%ID> = phi i64\*\*\* .*", "i64*** operation", "int*** operation"],
-    ["<%ID> = phi i128\*\*\* .*", "i128*** operation", "int*** operation"],
-    ["<%ID> = phi x86_fp80 .*", "float  operation", "floating point operation"],
-    ["<%ID> = phi float .*", "float  operation", "floating point operation"],
-    ["<%ID> = phi double .*", "double operation", "floating point operation"],
+    [r"<%ID> = phi i1\* .*", "i1*  operation", "int* operation"],
+    [r"<%ID> = phi i2\* .*", "i2*  operation", "int* operation"],
+    [r"<%ID> = phi i4\* .*", "i4*  operation", "int* operation"],
+    [r"<%ID> = phi i8\* .*", "i8*  operation", "int* operation"],
+    [r"<%ID> = phi i16\* .*", "i16*  operation", "int* operation"],
+    [r"<%ID> = phi i32\* .*", "i32*  operation", "int* operation"],
+    [r"<%ID> = phi i40\* .*", "i40*  operation", "int* operation"],
+    [r"<%ID> = phi i64\* .*", "i64*  operation", "int* operation"],
+    [r"<%ID> = phi i128\* .*", "i128*  operation", "int* operation"],
+    [r"<%ID> = phi i1\*\* .*", "i1**  operation", "int** operation"],
+    [r"<%ID> = phi i2\*\* .*", "i2**  operation", "int** operation"],
+    [r"<%ID> = phi i4\*\* .*", "i4**  operation", "int** operation"],
+    [r"<%ID> = phi i8\*\* .*", "i8**  operation", "int** operation"],
+    [r"<%ID> = phi i16\*\* .*", "i16** operation", "int** operation"],
+    [r"<%ID> = phi i32\*\* .*", "i32** operation", "int** operation"],
+    [r"<%ID> = phi i40\*\* .*", "i40** operation", "int** operation"],
+    [r"<%ID> = phi i64\*\* .*", "i64** operation", "int** operation"],
+    [r"<%ID> = phi i128\*\* .*", "i128** operation", "int** operation"],
+    [r"<%ID> = phi i1\*\*\* .*", "i1***  operation", "int*** operation"],
+    [r"<%ID> = phi i2\*\*\* .*", "i2***  operation", "int*** operation"],
+    [r"<%ID> = phi i4\*\*\* .*", "i4***  operation", "int*** operation"],
+    [r"<%ID> = phi i8\*\*\* .*", "i8***  operation", "int*** operation"],
+    [r"<%ID> = phi i16\*\*\* .*", "i16*** operation", "int*** operation"],
+    [r"<%ID> = phi i32\*\*\* .*", "i32*** operation", "int*** operation"],
+    [r"<%ID> = phi i64\*\*\* .*", "i64*** operation", "int*** operation"],
+    [r"<%ID> = phi i128\*\*\* .*", "i128*** operation", "int*** operation"],
+    [r"<%ID> = phi x86_fp80 .*", "float  operation", "floating point operation"],
+    [r"<%ID> = phi float .*", "float  operation", "floating point operation"],
+    [r"<%ID> = phi double .*", "double operation", "floating point operation"],
     [
-        "<%ID> = phi <\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = phi <\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = phi <\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = phi <\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = phi <\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = phi <\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = phi x86_fp80\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = phi x86_fp80\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = phi <\d+ x x86_fp80\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = phi <\d+ x x86_fp80\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x float\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = phi <\d+ x float\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x double\*> .*",
-        "<d x double*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = phi <\d+ x double\*> .*",
+        r"<d x double*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = phi <\d+ x x86_fp80>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = phi <\d+ x x86_fp80>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = phi <\d+ x float>\* .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = phi <\d+ x float>\* .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = phi <\d+ x double>\* .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = phi <\d+ x double>\* .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = phi x86_fp80\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = phi x86_fp80\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
-    ["<%ID> = phi float\* .*", "float*  operation", "floating point* operation"],
-    ["<%ID> = phi double\* .*", "double* operation", "floating point* operation"],
+    [r"<%ID> = phi float\* .*", "float*  operation", "floating point* operation"],
+    [r"<%ID> = phi double\* .*", "double* operation", "floating point* operation"],
     [
-        "<%ID> = phi x86_fp80\*\* .*",
-        "float**  operation",
-        "floating point** operation",
+        r"<%ID> = phi x86_fp80\*\* .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = phi float\*\* .*",
-        "float**  operation",
-        "floating point** operation",
+        r"<%ID> = phi float\*\* .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = phi double\*\* .*",
-        "double**  operation",
-        "floating point** operation",
+        r"<%ID> = phi double\*\* .*",
+        r"double**  operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = phi x86_fp80\*\*\* .*",
-        "float***  operation",
-        "floating point*** operation",
+        r"<%ID> = phi x86_fp80\*\*\* .*",
+        r"float***  operation",
+        r"floating point*** operation",
     ],
     [
-        "<%ID> = phi float\*\*\* .*",
-        "float***  operation",
-        "floating point*** operation",
+        r"<%ID> = phi float\*\*\* .*",
+        r"float***  operation",
+        r"floating point*** operation",
     ],
     [
-        "<%ID> = phi double\*\*\* .*",
-        "double***  operation",
-        "floating point*** operation",
+        r"<%ID> = phi double\*\*\* .*",
+        r"double***  operation",
+        r"floating point*** operation",
     ],
-    ["<%ID> = phi void \(.*\) \[.*", "function op", "function op"],
-    ["<%ID> = phi void \(.*\)\* \[.*", "function* op", "function* op"],
-    ["<%ID> = phi void \(.*\)\*\* \[.*", "function** op", "function** op"],
-    ["<%ID> = phi void \(.*\)\*\*\* \[.*", "function*** op", "function*** op"],
-    ["<%ID> = phi (<?{|opaque|<%ID>) .*", "struct/class op", "struct/class op"],
+    [r"<%ID> = phi void \(.*\) \[.*", "function op", "function op"],
+    [r"<%ID> = phi void \(.*\)\* \[.*", "function* op", "function* op"],
+    [r"<%ID> = phi void \(.*\)\*\* \[.*", "function** op", "function** op"],
+    [r"<%ID> = phi void \(.*\)\*\*\* \[.*", "function*** op", "function*** op"],
+    [r"<%ID> = phi (<?{|opaque|<%ID>) .*", "struct/class op", "struct/class op"],
     [
-        "<%ID> = phi (<?{|opaque|<%ID>)\* .*",
-        "struct/class* op",
-        "struct/class* op",
+        r"<%ID> = phi (<?{|opaque|<%ID>)\* .*",
+        r"struct/class* op",
+        r"struct/class* op",
     ],
     [
-        "<%ID> = phi (<?{|opaque|<%ID>)\*\* .*",
-        "struct/class** op",
-        "struct/class** op",
+        r"<%ID> = phi (<?{|opaque|<%ID>)\*\* .*",
+        r"struct/class** op",
+        r"struct/class** op",
     ],
     [
-        "<%ID> = phi (<?{|opaque|<%ID>)\*\*\* .*",
-        "struct/class*** op",
-        "struct/class*** op",
+        r"<%ID> = phi (<?{|opaque|<%ID>)\*\*\* .*",
+        r"struct/class*** op",
+        r"struct/class*** op",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i1, .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i1, .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i2, .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i2, .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i4, .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i4, .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i8, .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i8, .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i16, .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i16, .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i32, .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i32, .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i64, .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i64, .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i128, .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i128, .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i1\*, .*",
-        "i1*  operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i1\*, .*",
+        r"i1*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i2\*, .*",
-        "i2*  operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i2\*, .*",
+        r"i2*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i4\*, .*",
-        "i4*  operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i4\*, .*",
+        r"i4*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i8\*, .*",
-        "i8*  operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i8\*, .*",
+        r"i8*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i16\*, .*",
-        "i16* operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i16\*, .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i32\*, .*",
-        "i32* operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i32\*, .*",
+        r"i32* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i64\*, .*",
-        "i64* operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i64\*, .*",
+        r"i64* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i128\*, .*",
-        "i128* operation",
-        "int* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i128\*, .*",
+        r"i128* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i1\*\*, .*",
-        "i1**  operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i1\*\*, .*",
+        r"i1**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i2\*\*, .*",
-        "i2**  operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i2\*\*, .*",
+        r"i2**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i4\*\*, .*",
-        "i4**  operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i4\*\*, .*",
+        r"i4**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i8\*\*, .*",
-        "i8**  operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i8\*\*, .*",
+        r"i8**  operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i16\*\*, .*",
-        "i16** operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i16\*\*, .*",
+        r"i16** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i32\*\*, .*",
-        "i32** operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i32\*\*, .*",
+        r"i32** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i64\*\*, .*",
-        "i64** operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i64\*\*, .*",
+        r"i64** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "i128\*\*, .*",
-        "i128** operation",
-        "int** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"i128\*\*, .*",
+        r"i128** operation",
+        r"int** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "x86_fp80, .*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"x86_fp80, .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "float, .*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"float, .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "double, .*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"double, .*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "x86_fp80\*, .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"x86_fp80\*, .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "float\*, .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"float\*, .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "double\*, .*",
-        "double* operation",
-        "floating point* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"double\*, .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "x86_fp80\*\*, .*",
-        "float**  operation",
-        "floating point** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"x86_fp80\*\*, .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "float\*\*, .*",
-        "float**  operation",
-        "floating point** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"float\*\*, .*",
+        r"float**  operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "double\*\*, .*",
-        "double** operation",
-        "floating point** operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"double\*\*, .*",
+        r"double** operation",
+        r"floating point** operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + '%".*',
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r'%".*',
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<%.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<%.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<?{.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<?{.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "opaque.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"opaque.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i1>, .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i1>, .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i2>, .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i2>, .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i4>, .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i4>, .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i8>, .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i8>, .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i16>, .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i16>, .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i32>, .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i32>, .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i64>, .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i64>, .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i128>, .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i128>, .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x x86_fp80>, .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x x86_fp80>, .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x float>, .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x float>, .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x double>, .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x double>, .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i1>\*, .*",
-        "<d x i1>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i1>\*, .*",
+        r"<d x i1>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i2>\*, .*",
-        "<d x i2>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i2>\*, .*",
+        r"<d x i2>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i4>\*, .*",
-        "<d x i4>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i4>\*, .*",
+        r"<d x i4>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i8>\*, .*",
-        "<d x i8>*  operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i8>\*, .*",
+        r"<d x i8>*  operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i16>\*, .*",
-        "<d x i16>* operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i16>\*, .*",
+        r"<d x i16>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i32>\*, .*",
-        "<d x i32>* operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i32>\*, .*",
+        r"<d x i32>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i64>\*, .*",
-        "<d x i64>* operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i64>\*, .*",
+        r"<d x i64>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x i128>\*, .*",
-        "<d x i128>* operation",
-        "<d x int>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x i128>\*, .*",
+        r"<d x i128>* operation",
+        r"<d x int>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x x86_fp80>\*, .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x x86_fp80>\*, .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x float>\*, .*",
-        "<d x float>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x float>\*, .*",
+        r"<d x float>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "<\d+ x double>\*, .*",
-        "<d x double>* operation",
-        "<d x floating point>* operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"<\d+ x double>\*, .*",
+        r"<d x double>* operation",
+        r"<d x floating point>* operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i1\], .*",
-        "[d x i1]  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i1\], .*",
+        r"[d x i1]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i2\], .*",
-        "[d x i2]  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i2\], .*",
+        r"[d x i2]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i4\], .*",
-        "[d x i4]  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i4\], .*",
+        r"[d x i4]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i8\], .*",
-        "[d x i8]  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i8\], .*",
+        r"[d x i8]  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i16\], .*",
-        "[d x i16] operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i16\], .*",
+        r"[d x i16] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i32\], .*",
-        "[d x i32] operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i32\], .*",
+        r"[d x i32] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i64\], .*",
-        "[d x i64] operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i64\], .*",
+        r"[d x i64] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i128\], .*",
-        "[d x i128] operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i128\], .*",
+        r"[d x i128] operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x x86_fp80\], .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x x86_fp80\], .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x float\], .*",
-        "[d x float] operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x float\], .*",
+        r"[d x float] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x double\], .*",
-        "[d x double] operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x double\], .*",
+        r"[d x double] operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x .*\], .*",
-        "array of array operation",
-        "array of array operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x .*\], .*",
+        r"array of array operation",
+        r"array of array operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i1\]\*, .*",
-        "[d x i1]*  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i1\]\*, .*",
+        r"[d x i1]*  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i2\]\*, .*",
-        "[d x i2]*  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i2\]\*, .*",
+        r"[d x i2]*  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i4\]\*, .*",
-        "[d x i4]*  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i4\]\*, .*",
+        r"[d x i4]*  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i8\]\*, .*",
-        "[d x i8]*  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i8\]\*, .*",
+        r"[d x i8]*  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i16\]\*, .*",
-        "[d x i16]* operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i16\]\*, .*",
+        r"[d x i16]* operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i32\]\*, .*",
-        "[d x i32]* operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i32\]\*, .*",
+        r"[d x i32]* operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i64\]\*, .*",
-        "[d x i64]* operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i64\]\*, .*",
+        r"[d x i64]* operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i128\]\*, .*",
-        "[d x i128]* operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i128\]\*, .*",
+        r"[d x i128]* operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x x86_fp80\]\*, .*",
-        "[d x float]* operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x x86_fp80\]\*, .*",
+        r"[d x float]* operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x float\]\*, .*",
-        "[d x float]* operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x float\]\*, .*",
+        r"[d x float]* operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x double\]\*, .*",
-        "[d x double]* operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x double\]\*, .*",
+        r"[d x double]* operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x .*\]\*, .*",
-        "array of array* operation",
-        "array of array operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x .*\]\*, .*",
+        r"array of array* operation",
+        r"array of array operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i1\]\*\*, .*",
-        "[d x i1]**  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i1\]\*\*, .*",
+        r"[d x i1]**  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i2\]\*\*, .*",
-        "[d x i2]**  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i2\]\*\*, .*",
+        r"[d x i2]**  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i4\]\*\*, .*",
-        "[d x i4]**  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i4\]\*\*, .*",
+        r"[d x i4]**  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i8\]\*\*, .*",
-        "[d x i8]**  operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i8\]\*\*, .*",
+        r"[d x i8]**  operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i16\]\*\*, .*",
-        "[d x i16]** operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i16\]\*\*, .*",
+        r"[d x i16]** operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i32\]\*\*, .*",
-        "[d x i32]** operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i32\]\*\*, .*",
+        r"[d x i32]** operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i64\]\*\*, .*",
-        "[d x i64]** operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i64\]\*\*, .*",
+        r"[d x i64]** operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x i128\]\*\*, .*",
-        "[d x i128]** operation",
-        "[d x int] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x i128\]\*\*, .*",
+        r"[d x i128]** operation",
+        r"[d x int] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x x86_fp80\]\*\*, .*",
-        "[d x float]** operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x x86_fp80\]\*\*, .*",
+        r"[d x float]** operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x float\]\*\*, .*",
-        "[d x float]** operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x float\]\*\*, .*",
+        r"[d x float]** operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x double\]\*\*, .*",
-        "[d x double]** operation",
-        "[d x floating point] operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x double\]\*\*, .*",
+        r"[d x double]** operation",
+        r"[d x floating point] operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + "\[\d+ x .*\], .*",
-        "array of array** operation",
-        "array of array operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r"\[\d+ x .*\], .*",
+        r"array of array** operation",
+        r"array of array operation",
     ],
     [
-        "<%ID> = getelementptr " + any_of(opt_GEP) + ".*\(.*\)\*+, .*",
-        "function operation",
-        "function operation",
+        r"<%ID> = getelementptr " + any_of(opt_GEP) + r".*\(.*\)\*+, .*",
+        r"function operation",
+        r"function operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i1 .*",
-        "i1  operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i1 .*",
+        r"i1  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i2 .*",
-        "i2  operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i2 .*",
+        r"i2  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i4 .*",
-        "i4  operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i4 .*",
+        r"i4  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i8 .*",
-        "i8  operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i8 .*",
+        r"i8  operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i16 .*",
-        "i16 operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i16 .*",
+        r"i16 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i32 .*",
-        "i32 operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i32 .*",
+        r"i32 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i64 .*",
-        "i64 operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i64 .*",
+        r"i64 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i128 .*",
-        "i128 operation",
-        "int operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i128 .*",
+        r"i128 operation",
+        r"int operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i1\* .*",
-        "i1*  operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i1\* .*",
+        r"i1*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i2\* .*",
-        "i2*  operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i2\* .*",
+        r"i2*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i4\* .*",
-        "i4*  operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i4\* .*",
+        r"i4*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i8\* .*",
-        "i8*  operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i8\* .*",
+        r"i8*  operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i16\* .*",
-        "i16* operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i16\* .*",
+        r"i16* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i32\* .*",
-        "i32* operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i32\* .*",
+        r"i32* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i64\* .*",
-        "i64* operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i64\* .*",
+        r"i64* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*i128\* .*",
-        "i128* operation",
-        "int* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*i128\* .*",
+        r"i128* operation",
+        r"int* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*x86_fp80 .*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*x86_fp80 .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*float .*",
-        "float  operation",
-        "floating point operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*float .*",
+        r"float  operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*double .*",
-        "double operation",
-        "floating point operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*double .*",
+        r"double operation",
+        r"floating point operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*x86_fp80\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*x86_fp80\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*float\* .*",
-        "float*  operation",
-        "floating point* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*float\* .*",
+        r"float*  operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*double\* .*",
-        "double* operation",
-        "floating point* operation",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*double\* .*",
+        r"double* operation",
+        r"floating point* operation",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + '*%".*',
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r'*%".*',
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*<?{.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*<?{.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + "*opaque.*",
-        "struct/class op",
-        "struct/class op",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r"*opaque.*",
+        r"struct/class op",
+        r"struct/class op",
     ],
     [
-        "<%ID> = invoke " + any_of(opt_invoke) + '*%".*\*.*',
-        "struct/class* op",
-        "struct/class op",
+        r"<%ID> = invoke " + any_of(opt_invoke) + r'*%".*\*.*',
+        r"struct/class* op",
+        r"struct/class op",
     ],
-    ["<%ID> = invoke " + any_of(opt_invoke) + "*void .*", "void op", "void op"],
-    ["invoke " + any_of(opt_invoke) + "*void .*", "void op", "void op"],
+    [r"<%ID> = invoke " + any_of(opt_invoke) + r"*void .*", "void op", "void op"],
+    [r"invoke " + any_of(opt_invoke) + r"*void .*", "void op", "void op"],
     [
-        "<%ID> = extractelement <\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i1\*> .*",
-        "<d x i1*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i1\*> .*",
+        r"<d x i1*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i2\*> .*",
-        "<d x i2*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i2\*> .*",
+        r"<d x i2*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i4\*> .*",
-        "<d x i4*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i4\*> .*",
+        r"<d x i4*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i8\*> .*",
-        "<d x i8*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i8\*> .*",
+        r"<d x i8*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i16\*> .*",
-        "<d x i16*> operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i16\*> .*",
+        r"<d x i16*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i32\*> .*",
-        "<d x i32*> operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i32\*> .*",
+        r"<d x i32*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i64\*> .*",
-        "<d x i64*> operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i64\*> .*",
+        r"<d x i64*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = extractelement <\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x i128\*> .*",
-        "<d x i128*> operation",
-        "<d x int*> operation",
+        r"<%ID> = extractelement <\d+ x i128\*> .*",
+        r"<d x i128*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = extractelement <\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x x86_fp80\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = extractelement <\d+ x x86_fp80\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = extractelement <\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x float\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = extractelement <\d+ x float\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = extractelement <\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x double\*> .*",
-        "<d x double*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = extractelement <\d+ x double\*> .*",
+        r"<d x double*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x \{.*\}> .*",
-        "<d x struct> operation",
-        "<d x struct> operation",
+        r"<%ID> = extractelement <\d+ x \{.*\}> .*",
+        r"<d x struct> operation",
+        r"<d x struct> operation",
     ],
     [
-        "<%ID> = extractelement <\d+ x \{.*\}\*> .*",
-        "<d x struct*> operation",
-        "<d x struct*> operation",
+        r"<%ID> = extractelement <\d+ x \{.*\}\*> .*",
+        r"<d x struct*> operation",
+        r"<d x struct*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i1\*> .*",
-        "<d x i1*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i1\*> .*",
+        r"<d x i1*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i2\*> .*",
-        "<d x i2*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i2\*> .*",
+        r"<d x i2*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i4\*> .*",
-        "<d x i4*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i4\*> .*",
+        r"<d x i4*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i8\*> .*",
-        "<d x i8*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i8\*> .*",
+        r"<d x i8*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i16\*> .*",
-        "<d x i16*> operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i16\*> .*",
+        r"<d x i16*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i32\*> .*",
-        "<d x i32*> operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i32\*> .*",
+        r"<d x i32*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i64\*> .*",
-        "<d x i64*> operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i64\*> .*",
+        r"<d x i64*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = insertelement <\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x i128\*> .*",
-        "<d x i128*> operation",
-        "<d x int*> operation",
+        r"<%ID> = insertelement <\d+ x i128\*> .*",
+        r"<d x i128*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = insertelement <\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x x86_fp80\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = insertelement <\d+ x x86_fp80\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = insertelement <\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x float\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = insertelement <\d+ x float\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = insertelement <\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x double\*> .*",
-        "<d x double*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = insertelement <\d+ x double\*> .*",
+        r"<d x double*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x \{.*\}> .*",
-        "<d x struct> operation",
-        "<d x struct> operation",
+        r"<%ID> = insertelement <\d+ x \{.*\}> .*",
+        r"<d x struct> operation",
+        r"<d x struct> operation",
     ],
     [
-        "<%ID> = insertelement <\d+ x \{.*\}\*> .*",
-        "<d x struct*> operation",
-        "<d x struct*> operation",
+        r"<%ID> = insertelement <\d+ x \{.*\}\*> .*",
+        r"<d x struct*> operation",
+        r"<d x struct*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i1> .*",
-        "<d x i1>  operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i1> .*",
+        r"<d x i1>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i1\*> .*",
-        "<d x i1*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i1\*> .*",
+        r"<d x i1*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i2> .*",
-        "<d x i2>  operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i2> .*",
+        r"<d x i2>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i2\*> .*",
-        "<d x i2*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i2\*> .*",
+        r"<d x i2*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i4> .*",
-        "<d x i4>  operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i4> .*",
+        r"<d x i4>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i4\*> .*",
-        "<d x i4*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i4\*> .*",
+        r"<d x i4*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i8> .*",
-        "<d x i8>  operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i8> .*",
+        r"<d x i8>  operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i8\*> .*",
-        "<d x i8*>  operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i8\*> .*",
+        r"<d x i8*>  operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i16> .*",
-        "<d x i16> operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i16> .*",
+        r"<d x i16> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i16\*> .*",
-        "<d x i16*> operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i16\*> .*",
+        r"<d x i16*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i32> .*",
-        "<d x i32> operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i32> .*",
+        r"<d x i32> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i32\*> .*",
-        "<d x i32*> operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i32\*> .*",
+        r"<d x i32*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i64> .*",
-        "<d x i64> operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i64> .*",
+        r"<d x i64> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i64\*> .*",
-        "<d x i64*> operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i64\*> .*",
+        r"<d x i64*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i128> .*",
-        "<d x i128> operation",
-        "<d x int> operation",
+        r"<%ID> = shufflevector <\d+ x i128> .*",
+        r"<d x i128> operation",
+        r"<d x int> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x i128\*> .*",
-        "<d x i128*> operation",
-        "<d x int*> operation",
+        r"<%ID> = shufflevector <\d+ x i128\*> .*",
+        r"<d x i128*> operation",
+        r"<d x int*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x x86_fp80> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = shufflevector <\d+ x x86_fp80> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x x86_fp80\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = shufflevector <\d+ x x86_fp80\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x float> .*",
-        "<d x float> operation",
-        "<d x floating point> operation",
+        r"<%ID> = shufflevector <\d+ x float> .*",
+        r"<d x float> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x float\*> .*",
-        "<d x float*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = shufflevector <\d+ x float\*> .*",
+        r"<d x float*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x double> .*",
-        "<d x double> operation",
-        "<d x floating point> operation",
+        r"<%ID> = shufflevector <\d+ x double> .*",
+        r"<d x double> operation",
+        r"<d x floating point> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x double\*> .*",
-        "<d x double*> operation",
-        "<d x floating point*> operation",
+        r"<%ID> = shufflevector <\d+ x double\*> .*",
+        r"<d x double*> operation",
+        r"<d x floating point*> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x \{.*\}> .*",
-        "<d x struct> operation",
-        "<d x struct> operation",
+        r"<%ID> = shufflevector <\d+ x \{.*\}> .*",
+        r"<d x struct> operation",
+        r"<d x struct> operation",
     ],
     [
-        "<%ID> = shufflevector <\d+ x \{.*\}\*> .*",
-        "<d x struct*> operation",
-        "<d x struct*> operation",
+        r"<%ID> = shufflevector <\d+ x \{.*\}\*> .*",
+        r"<d x struct*> operation",
+        r"<d x struct*> operation",
     ],
     [
-        "<%ID> = bitcast void \(.* to .*",
-        "in-between operation",
-        "in-between operation",
+        r"<%ID> = bitcast void \(.* to .*",
+        r"in-between operation",
+        r"in-between operation",
     ],
     [
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque) .* to .*",
-        "in-between operation",
-        "in-between operation",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque) .* to .*",
+        r"in-between operation",
+        r"in-between operation",
     ],
     [
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\* .* to .*",
-        "in-between operation",
-        "in-between operation",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\* .* to .*",
+        r"in-between operation",
+        r"in-between operation",
     ],
     [
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\* .* to .*",
-        "in-between operation",
-        "in-between operation",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\* .* to .*",
+        r"in-between operation",
+        r"in-between operation",
     ],
     [
-        "<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\*\* .* to .*",
-        "in-between operation",
-        "in-between operation",
+        r"<%ID> = bitcast (i\d+|float|double|x86_fp80|opaque)\*\*\* .* to .*",
+        r"in-between operation",
+        r"in-between operation",
     ],
     [
-        "<%ID> = bitcast \[\d+.* to .*",
-        "in-between operation",
-        "in-between operation",
+        r"<%ID> = bitcast \[\d+.* to .*",
+        r"in-between operation",
+        r"in-between operation",
     ],
     [
-        "<%ID> = bitcast <\d+.* to .*",
-        "in-between operation",
-        "in-between operation",
+        r"<%ID> = bitcast <\d+.* to .*",
+        r"in-between operation",
+        r"in-between operation",
     ],
     [
-        '<%ID> = bitcast (%"|<%|<?{).* to .*',
-        "in-between operation",
-        "in-between operation",
+        r'<%ID> = bitcast (%"|<%|<?{).* to .*',
+        r"in-between operation",
+        r"in-between operation",
     ],
-    ["<%ID> = fpext .*", "in-between operation", "in-between operation"],
-    ["<%ID> = fptrunc .*", "in-between operation", "in-between operation"],
-    ["<%ID> = sext .*", "in-between operation", "in-between operation"],
-    ["<%ID> = trunc .* to .*", "in-between operation", "in-between operation"],
-    ["<%ID> = zext .*", "in-between operation", "in-between operation"],
-    ["<%ID> = sitofp .*", "in-between operation", "in-between operation"],
-    ["<%ID> = uitofp .*", "in-between operation", "in-between operation"],
-    ["<%ID> = inttoptr .*", "in-between operation", "in-between operation"],
-    ["<%ID> = ptrtoint .*", "in-between operation", "in-between operation"],
-    ["<%ID> = fptosi .*", "in-between operation", "in-between operation"],
-    ["<%ID> = fptoui .*", "in-between operation", "in-between operation"],
-    ["<%ID> = extractvalue .*", "in-between operation", "in-between operation"],
-    ["<%ID> = insertvalue .*", "in-between operation", "in-between operation"],
-    ["resume .*", "in-between operation", "in-between operation"],
-    ["(tail |musttail |notail )?call( \w+)? void .*", "call void", "call void"],
-    ["i\d{1,2} <(INT|FLOAT)>, label <%ID>", "blob", "blob"],
-    ["<%ID> = select .*", "blob", "blob"],
-    [".*to label.*unwind label.*", "blob", "blob"],
-    ["catch .*", "blob", "blob"],
-    ["cleanup", "blob", "blob"],
-    ["<%ID> = landingpad .", "blob", "blob"],
-    ["; <label>:<LABEL>", "blob", "blob"],
-    ["<LABEL>:", "blob", "blob"],
-    ["br i1 .*", "blob", "blob"],
-    ["br label .*", "blob", "blob"],
-    ["indirectbr .*", "blob", "blob"],
-    ["switch .*", "blob", "blob"],
-    ["unreachable.*", "blob", "blob"],
-    ["ret void", "blob", "blob"],
-    ["!UNK", "blob", "blob"],
+    [r"<%ID> = fpext .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = fptrunc .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = sext .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = trunc .* to .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = zext .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = sitofp .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = uitofp .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = inttoptr .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = ptrtoint .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = fptosi .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = fptoui .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = extractvalue .*", "in-between operation", "in-between operation"],
+    [r"<%ID> = insertvalue .*", "in-between operation", "in-between operation"],
+    [r"resume .*", "in-between operation", "in-between operation"],
+    [r"(tail |musttail |notail )?call( \w+)? void .*", "call void", "call void"],
+    [r"i\d{1,2} <(INT|FLOAT)>, label <%ID>", "blob", "blob"],
+    [r"<%ID> = select .*", "blob", "blob"],
+    [r".*to label.*unwind label.*", "blob", "blob"],
+    [r"catch .*", "blob", "blob"],
+    [r"cleanup", "blob", "blob"],
+    [r"<%ID> = landingpad .", "blob", "blob"],
+    [r"; <label>:<LABEL>", "blob", "blob"],
+    [r"<LABEL>:", "blob", "blob"],
+    [r"br i1 .*", "blob", "blob"],
+    [r"br label .*", "blob", "blob"],
+    [r"indirectbr .*", "blob", "blob"],
+    [r"switch .*", "blob", "blob"],
+    [r"unreachable.*", "blob", "blob"],
+    [r"ret void", "blob", "blob"],
+    [r"!UNK", "blob", "blob"],
 ]