Home | History | Annotate | Download | only in nir 
      1 
      2 #include "nir.h"
      3 #include "nir_search.h"
      4 
      5 #ifndef NIR_OPT_ALGEBRAIC_STRUCT_DEFS
      6 #define NIR_OPT_ALGEBRAIC_STRUCT_DEFS
      7 
      8 struct transform {
      9    const nir_search_expression *search;
     10    const nir_search_value *replace;
     11    unsigned condition_offset;
     12 };
     13 
     14 #endif
     15 
     16 
     17 #include "compiler/nir/nir_search_helpers.h"
     18 static const nir_search_variable search111_0 = {
     19    { nir_search_value_variable, 32 },
     20    0, /* a */
     21    false,
     22    nir_type_bool32,
     23    NULL,
     24 };
     25 
     26 #include "compiler/nir/nir_search_helpers.h"
     27 static const nir_search_constant search111_1 = {
     28    { nir_search_value_constant, 0 },
     29    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
     30 };
     31 #include "compiler/nir/nir_search_helpers.h"
     32 static const nir_search_expression search111 = {
     33    { nir_search_value_expression, 0 },
     34    false,
     35    nir_op_iand,
     36    { &search111_0.value, &search111_1.value },
     37    NULL,
     38 };
     39 
     40 #include "compiler/nir/nir_search_helpers.h"
     41 static const nir_search_variable replace111_0 = {
     42    { nir_search_value_variable, 0 },
     43    0, /* a */
     44    false,
     45    nir_type_invalid,
     46    NULL,
     47 };
     48 #include "compiler/nir/nir_search_helpers.h"
     49 static const nir_search_expression replace111 = {
     50    { nir_search_value_expression, 0 },
     51    false,
     52    nir_op_b2f,
     53    { &replace111_0.value },
     54    NULL,
     55 };
     56 
     57 #include "compiler/nir/nir_search_helpers.h"
     58 static const nir_search_variable search122_0 = {
     59    { nir_search_value_variable, 0 },
     60    0, /* a */
     61    false,
     62    nir_type_invalid,
     63    NULL,
     64 };
     65 
     66 #include "compiler/nir/nir_search_helpers.h"
     67 static const nir_search_variable search122_1 = {
     68    { nir_search_value_variable, 0 },
     69    0, /* a */
     70    false,
     71    nir_type_invalid,
     72    NULL,
     73 };
     74 #include "compiler/nir/nir_search_helpers.h"
     75 static const nir_search_expression search122 = {
     76    { nir_search_value_expression, 0 },
     77    false,
     78    nir_op_iand,
     79    { &search122_0.value, &search122_1.value },
     80    NULL,
     81 };
     82 
     83 #include "compiler/nir/nir_search_helpers.h"
     84 static const nir_search_variable replace122 = {
     85    { nir_search_value_variable, 0 },
     86    0, /* a */
     87    false,
     88    nir_type_invalid,
     89    NULL,
     90 };
     91 
     92 #include "compiler/nir/nir_search_helpers.h"
     93 static const nir_search_variable search123_0 = {
     94    { nir_search_value_variable, 0 },
     95    0, /* a */
     96    false,
     97    nir_type_invalid,
     98    NULL,
     99 };
    100 
    101 #include "compiler/nir/nir_search_helpers.h"
    102 static const nir_search_constant search123_1 = {
    103    { nir_search_value_constant, 0 },
    104    nir_type_int, { -0x1 /* -1 */ },
    105 };
    106 #include "compiler/nir/nir_search_helpers.h"
    107 static const nir_search_expression search123 = {
    108    { nir_search_value_expression, 0 },
    109    false,
    110    nir_op_iand,
    111    { &search123_0.value, &search123_1.value },
    112    NULL,
    113 };
    114 
    115 #include "compiler/nir/nir_search_helpers.h"
    116 static const nir_search_variable replace123 = {
    117    { nir_search_value_variable, 0 },
    118    0, /* a */
    119    false,
    120    nir_type_invalid,
    121    NULL,
    122 };
    123 
    124 #include "compiler/nir/nir_search_helpers.h"
    125 static const nir_search_variable search124_0 = {
    126    { nir_search_value_variable, 0 },
    127    0, /* a */
    128    false,
    129    nir_type_invalid,
    130    NULL,
    131 };
    132 
    133 #include "compiler/nir/nir_search_helpers.h"
    134 static const nir_search_constant search124_1 = {
    135    { nir_search_value_constant, 0 },
    136    nir_type_int, { 0x0 /* 0 */ },
    137 };
    138 #include "compiler/nir/nir_search_helpers.h"
    139 static const nir_search_expression search124 = {
    140    { nir_search_value_expression, 0 },
    141    false,
    142    nir_op_iand,
    143    { &search124_0.value, &search124_1.value },
    144    NULL,
    145 };
    146 
    147 #include "compiler/nir/nir_search_helpers.h"
    148 static const nir_search_constant replace124 = {
    149    { nir_search_value_constant, 0 },
    150    nir_type_int, { 0x0 /* 0 */ },
    151 };
    152 
    153 #include "compiler/nir/nir_search_helpers.h"
    154 static const nir_search_variable search132_0_0 = {
    155    { nir_search_value_variable, 0 },
    156    0, /* a */
    157    false,
    158    nir_type_invalid,
    159    NULL,
    160 };
    161 #include "compiler/nir/nir_search_helpers.h"
    162 static const nir_search_expression search132_0 = {
    163    { nir_search_value_expression, 0 },
    164    false,
    165    nir_op_inot,
    166    { &search132_0_0.value },
    167    NULL,
    168 };
    169 
    170 #include "compiler/nir/nir_search_helpers.h"
    171 static const nir_search_variable search132_1_0 = {
    172    { nir_search_value_variable, 0 },
    173    1, /* b */
    174    false,
    175    nir_type_invalid,
    176    NULL,
    177 };
    178 #include "compiler/nir/nir_search_helpers.h"
    179 static const nir_search_expression search132_1 = {
    180    { nir_search_value_expression, 0 },
    181    false,
    182    nir_op_inot,
    183    { &search132_1_0.value },
    184    NULL,
    185 };
    186 #include "compiler/nir/nir_search_helpers.h"
    187 static const nir_search_expression search132 = {
    188    { nir_search_value_expression, 0 },
    189    false,
    190    nir_op_iand,
    191    { &search132_0.value, &search132_1.value },
    192    NULL,
    193 };
    194 
    195 #include "compiler/nir/nir_search_helpers.h"
    196 static const nir_search_variable replace132_0_0 = {
    197    { nir_search_value_variable, 0 },
    198    0, /* a */
    199    false,
    200    nir_type_invalid,
    201    NULL,
    202 };
    203 
    204 #include "compiler/nir/nir_search_helpers.h"
    205 static const nir_search_variable replace132_0_1 = {
    206    { nir_search_value_variable, 0 },
    207    1, /* b */
    208    false,
    209    nir_type_invalid,
    210    NULL,
    211 };
    212 #include "compiler/nir/nir_search_helpers.h"
    213 static const nir_search_expression replace132_0 = {
    214    { nir_search_value_expression, 0 },
    215    false,
    216    nir_op_ior,
    217    { &replace132_0_0.value, &replace132_0_1.value },
    218    NULL,
    219 };
    220 #include "compiler/nir/nir_search_helpers.h"
    221 static const nir_search_expression replace132 = {
    222    { nir_search_value_expression, 0 },
    223    false,
    224    nir_op_inot,
    225    { &replace132_0.value },
    226    NULL,
    227 };
    228 
    229 #include "compiler/nir/nir_search_helpers.h"
    230 static const nir_search_constant search140_0 = {
    231    { nir_search_value_constant, 0 },
    232    nir_type_int, { 0xff /* 255 */ },
    233 };
    234 
    235 #include "compiler/nir/nir_search_helpers.h"
    236 static const nir_search_variable search140_1_0 = {
    237    { nir_search_value_variable, 0 },
    238    0, /* a */
    239    false,
    240    nir_type_invalid,
    241    NULL,
    242 };
    243 
    244 #include "compiler/nir/nir_search_helpers.h"
    245 static const nir_search_constant search140_1_1 = {
    246    { nir_search_value_constant, 0 },
    247    nir_type_int, { 0x18 /* 24 */ },
    248 };
    249 #include "compiler/nir/nir_search_helpers.h"
    250 static const nir_search_expression search140_1 = {
    251    { nir_search_value_expression, 0 },
    252    false,
    253    nir_op_ushr,
    254    { &search140_1_0.value, &search140_1_1.value },
    255    NULL,
    256 };
    257 #include "compiler/nir/nir_search_helpers.h"
    258 static const nir_search_expression search140 = {
    259    { nir_search_value_expression, 0 },
    260    false,
    261    nir_op_iand,
    262    { &search140_0.value, &search140_1.value },
    263    NULL,
    264 };
    265 
    266 #include "compiler/nir/nir_search_helpers.h"
    267 static const nir_search_variable replace140_0 = {
    268    { nir_search_value_variable, 0 },
    269    0, /* a */
    270    false,
    271    nir_type_invalid,
    272    NULL,
    273 };
    274 
    275 #include "compiler/nir/nir_search_helpers.h"
    276 static const nir_search_constant replace140_1 = {
    277    { nir_search_value_constant, 0 },
    278    nir_type_int, { 0x18 /* 24 */ },
    279 };
    280 #include "compiler/nir/nir_search_helpers.h"
    281 static const nir_search_expression replace140 = {
    282    { nir_search_value_expression, 0 },
    283    false,
    284    nir_op_ushr,
    285    { &replace140_0.value, &replace140_1.value },
    286    NULL,
    287 };
    288 
    289 #include "compiler/nir/nir_search_helpers.h"
    290 static const nir_search_constant search141_0 = {
    291    { nir_search_value_constant, 0 },
    292    nir_type_int, { 0xffff /* 65535 */ },
    293 };
    294 
    295 #include "compiler/nir/nir_search_helpers.h"
    296 static const nir_search_variable search141_1_0 = {
    297    { nir_search_value_variable, 0 },
    298    0, /* a */
    299    false,
    300    nir_type_invalid,
    301    NULL,
    302 };
    303 
    304 #include "compiler/nir/nir_search_helpers.h"
    305 static const nir_search_constant search141_1_1 = {
    306    { nir_search_value_constant, 0 },
    307    nir_type_int, { 0x10 /* 16 */ },
    308 };
    309 #include "compiler/nir/nir_search_helpers.h"
    310 static const nir_search_expression search141_1 = {
    311    { nir_search_value_expression, 0 },
    312    false,
    313    nir_op_ushr,
    314    { &search141_1_0.value, &search141_1_1.value },
    315    NULL,
    316 };
    317 #include "compiler/nir/nir_search_helpers.h"
    318 static const nir_search_expression search141 = {
    319    { nir_search_value_expression, 0 },
    320    false,
    321    nir_op_iand,
    322    { &search141_0.value, &search141_1.value },
    323    NULL,
    324 };
    325 
    326 #include "compiler/nir/nir_search_helpers.h"
    327 static const nir_search_variable replace141_0 = {
    328    { nir_search_value_variable, 0 },
    329    0, /* a */
    330    false,
    331    nir_type_invalid,
    332    NULL,
    333 };
    334 
    335 #include "compiler/nir/nir_search_helpers.h"
    336 static const nir_search_constant replace141_1 = {
    337    { nir_search_value_constant, 0 },
    338    nir_type_int, { 0x10 /* 16 */ },
    339 };
    340 #include "compiler/nir/nir_search_helpers.h"
    341 static const nir_search_expression replace141 = {
    342    { nir_search_value_expression, 0 },
    343    false,
    344    nir_op_ushr,
    345    { &replace141_0.value, &replace141_1.value },
    346    NULL,
    347 };
    348 
    349 #include "compiler/nir/nir_search_helpers.h"
    350 static const nir_search_constant search190_0 = {
    351    { nir_search_value_constant, 0 },
    352    nir_type_int, { 0xff /* 255 */ },
    353 };
    354 
    355 #include "compiler/nir/nir_search_helpers.h"
    356 static const nir_search_variable search190_1_0 = {
    357    { nir_search_value_variable, 0 },
    358    0, /* a */
    359    false,
    360    nir_type_invalid,
    361    NULL,
    362 };
    363 
    364 #include "compiler/nir/nir_search_helpers.h"
    365 static const nir_search_constant search190_1_1 = {
    366    { nir_search_value_constant, 0 },
    367    nir_type_int, { 0x10 /* 16 */ },
    368 };
    369 #include "compiler/nir/nir_search_helpers.h"
    370 static const nir_search_expression search190_1 = {
    371    { nir_search_value_expression, 0 },
    372    false,
    373    nir_op_ushr,
    374    { &search190_1_0.value, &search190_1_1.value },
    375    NULL,
    376 };
    377 #include "compiler/nir/nir_search_helpers.h"
    378 static const nir_search_expression search190 = {
    379    { nir_search_value_expression, 0 },
    380    false,
    381    nir_op_iand,
    382    { &search190_0.value, &search190_1.value },
    383    NULL,
    384 };
    385 
    386 #include "compiler/nir/nir_search_helpers.h"
    387 static const nir_search_variable replace190_0 = {
    388    { nir_search_value_variable, 0 },
    389    0, /* a */
    390    false,
    391    nir_type_invalid,
    392    NULL,
    393 };
    394 
    395 #include "compiler/nir/nir_search_helpers.h"
    396 static const nir_search_constant replace190_1 = {
    397    { nir_search_value_constant, 0 },
    398    nir_type_int, { 0x2 /* 2 */ },
    399 };
    400 #include "compiler/nir/nir_search_helpers.h"
    401 static const nir_search_expression replace190 = {
    402    { nir_search_value_expression, 0 },
    403    false,
    404    nir_op_extract_u8,
    405    { &replace190_0.value, &replace190_1.value },
    406    NULL,
    407 };
    408 
    409 #include "compiler/nir/nir_search_helpers.h"
    410 static const nir_search_constant search191_0 = {
    411    { nir_search_value_constant, 0 },
    412    nir_type_int, { 0xff /* 255 */ },
    413 };
    414 
    415 #include "compiler/nir/nir_search_helpers.h"
    416 static const nir_search_variable search191_1_0 = {
    417    { nir_search_value_variable, 0 },
    418    0, /* a */
    419    false,
    420    nir_type_invalid,
    421    NULL,
    422 };
    423 
    424 #include "compiler/nir/nir_search_helpers.h"
    425 static const nir_search_constant search191_1_1 = {
    426    { nir_search_value_constant, 0 },
    427    nir_type_int, { 0x8 /* 8 */ },
    428 };
    429 #include "compiler/nir/nir_search_helpers.h"
    430 static const nir_search_expression search191_1 = {
    431    { nir_search_value_expression, 0 },
    432    false,
    433    nir_op_ushr,
    434    { &search191_1_0.value, &search191_1_1.value },
    435    NULL,
    436 };
    437 #include "compiler/nir/nir_search_helpers.h"
    438 static const nir_search_expression search191 = {
    439    { nir_search_value_expression, 0 },
    440    false,
    441    nir_op_iand,
    442    { &search191_0.value, &search191_1.value },
    443    NULL,
    444 };
    445 
    446 #include "compiler/nir/nir_search_helpers.h"
    447 static const nir_search_variable replace191_0 = {
    448    { nir_search_value_variable, 0 },
    449    0, /* a */
    450    false,
    451    nir_type_invalid,
    452    NULL,
    453 };
    454 
    455 #include "compiler/nir/nir_search_helpers.h"
    456 static const nir_search_constant replace191_1 = {
    457    { nir_search_value_constant, 0 },
    458    nir_type_int, { 0x1 /* 1 */ },
    459 };
    460 #include "compiler/nir/nir_search_helpers.h"
    461 static const nir_search_expression replace191 = {
    462    { nir_search_value_expression, 0 },
    463    false,
    464    nir_op_extract_u8,
    465    { &replace191_0.value, &replace191_1.value },
    466    NULL,
    467 };
    468 
    469 #include "compiler/nir/nir_search_helpers.h"
    470 static const nir_search_constant search192_0 = {
    471    { nir_search_value_constant, 0 },
    472    nir_type_int, { 0xff /* 255 */ },
    473 };
    474 
    475 #include "compiler/nir/nir_search_helpers.h"
    476 static const nir_search_variable search192_1 = {
    477    { nir_search_value_variable, 0 },
    478    0, /* a */
    479    false,
    480    nir_type_invalid,
    481    NULL,
    482 };
    483 #include "compiler/nir/nir_search_helpers.h"
    484 static const nir_search_expression search192 = {
    485    { nir_search_value_expression, 0 },
    486    false,
    487    nir_op_iand,
    488    { &search192_0.value, &search192_1.value },
    489    NULL,
    490 };
    491 
    492 #include "compiler/nir/nir_search_helpers.h"
    493 static const nir_search_variable replace192_0 = {
    494    { nir_search_value_variable, 0 },
    495    0, /* a */
    496    false,
    497    nir_type_invalid,
    498    NULL,
    499 };
    500 
    501 #include "compiler/nir/nir_search_helpers.h"
    502 static const nir_search_constant replace192_1 = {
    503    { nir_search_value_constant, 0 },
    504    nir_type_int, { 0x0 /* 0 */ },
    505 };
    506 #include "compiler/nir/nir_search_helpers.h"
    507 static const nir_search_expression replace192 = {
    508    { nir_search_value_expression, 0 },
    509    false,
    510    nir_op_extract_u8,
    511    { &replace192_0.value, &replace192_1.value },
    512    NULL,
    513 };
    514 
    515 #include "compiler/nir/nir_search_helpers.h"
    516 static const nir_search_constant search194_0 = {
    517    { nir_search_value_constant, 0 },
    518    nir_type_int, { 0xffff /* 65535 */ },
    519 };
    520 
    521 #include "compiler/nir/nir_search_helpers.h"
    522 static const nir_search_variable search194_1 = {
    523    { nir_search_value_variable, 0 },
    524    0, /* a */
    525    false,
    526    nir_type_invalid,
    527    NULL,
    528 };
    529 #include "compiler/nir/nir_search_helpers.h"
    530 static const nir_search_expression search194 = {
    531    { nir_search_value_expression, 0 },
    532    false,
    533    nir_op_iand,
    534    { &search194_0.value, &search194_1.value },
    535    NULL,
    536 };
    537 
    538 #include "compiler/nir/nir_search_helpers.h"
    539 static const nir_search_variable replace194_0 = {
    540    { nir_search_value_variable, 0 },
    541    0, /* a */
    542    false,
    543    nir_type_invalid,
    544    NULL,
    545 };
    546 
    547 #include "compiler/nir/nir_search_helpers.h"
    548 static const nir_search_constant replace194_1 = {
    549    { nir_search_value_constant, 0 },
    550    nir_type_int, { 0x0 /* 0 */ },
    551 };
    552 #include "compiler/nir/nir_search_helpers.h"
    553 static const nir_search_expression replace194 = {
    554    { nir_search_value_expression, 0 },
    555    false,
    556    nir_op_extract_u16,
    557    { &replace194_0.value, &replace194_1.value },
    558    NULL,
    559 };
    560 
    561 #include "compiler/nir/nir_search_helpers.h"
    562 static const nir_search_variable search236_0_0 = {
    563    { nir_search_value_variable, 0 },
    564    0, /* a */
    565    false,
    566    nir_type_invalid,
    567    NULL,
    568 };
    569 
    570 #include "compiler/nir/nir_search_helpers.h"
    571 static const nir_search_variable search236_0_1 = {
    572    { nir_search_value_variable, 0 },
    573    0, /* a */
    574    false,
    575    nir_type_invalid,
    576    NULL,
    577 };
    578 #include "compiler/nir/nir_search_helpers.h"
    579 static const nir_search_expression search236_0 = {
    580    { nir_search_value_expression, 0 },
    581    false,
    582    nir_op_feq,
    583    { &search236_0_0.value, &search236_0_1.value },
    584    NULL,
    585 };
    586 
    587 #include "compiler/nir/nir_search_helpers.h"
    588 static const nir_search_variable search236_1_0 = {
    589    { nir_search_value_variable, 0 },
    590    0, /* a */
    591    false,
    592    nir_type_invalid,
    593    NULL,
    594 };
    595 
    596 #include "compiler/nir/nir_search_helpers.h"
    597 static const nir_search_variable search236_1_1 = {
    598    { nir_search_value_variable, 0 },
    599    1, /* b */
    600    false,
    601    nir_type_invalid,
    602    NULL,
    603 };
    604 #include "compiler/nir/nir_search_helpers.h"
    605 static const nir_search_expression search236_1 = {
    606    { nir_search_value_expression, 0 },
    607    false,
    608    nir_op_flt,
    609    { &search236_1_0.value, &search236_1_1.value },
    610    NULL,
    611 };
    612 #include "compiler/nir/nir_search_helpers.h"
    613 static const nir_search_expression search236 = {
    614    { nir_search_value_expression, 0 },
    615    false,
    616    nir_op_iand,
    617    { &search236_0.value, &search236_1.value },
    618    NULL,
    619 };
    620 
    621 #include "compiler/nir/nir_search_helpers.h"
    622 static const nir_search_variable replace236_0 = {
    623    { nir_search_value_variable, 0 },
    624    0, /* a */
    625    false,
    626    nir_type_invalid,
    627    NULL,
    628 };
    629 
    630 #include "compiler/nir/nir_search_helpers.h"
    631 static const nir_search_variable replace236_1 = {
    632    { nir_search_value_variable, 0 },
    633    1, /* b */
    634    false,
    635    nir_type_invalid,
    636    NULL,
    637 };
    638 #include "compiler/nir/nir_search_helpers.h"
    639 static const nir_search_expression replace236 = {
    640    { nir_search_value_expression, 0 },
    641    false,
    642    nir_op_flt,
    643    { &replace236_0.value, &replace236_1.value },
    644    NULL,
    645 };
    646 
    647 #include "compiler/nir/nir_search_helpers.h"
    648 static const nir_search_variable search237_0_0 = {
    649    { nir_search_value_variable, 0 },
    650    0, /* a */
    651    false,
    652    nir_type_invalid,
    653    NULL,
    654 };
    655 
    656 #include "compiler/nir/nir_search_helpers.h"
    657 static const nir_search_variable search237_0_1 = {
    658    { nir_search_value_variable, 0 },
    659    0, /* a */
    660    false,
    661    nir_type_invalid,
    662    NULL,
    663 };
    664 #include "compiler/nir/nir_search_helpers.h"
    665 static const nir_search_expression search237_0 = {
    666    { nir_search_value_expression, 0 },
    667    false,
    668    nir_op_feq,
    669    { &search237_0_0.value, &search237_0_1.value },
    670    NULL,
    671 };
    672 
    673 #include "compiler/nir/nir_search_helpers.h"
    674 static const nir_search_variable search237_1_0 = {
    675    { nir_search_value_variable, 0 },
    676    1, /* b */
    677    false,
    678    nir_type_invalid,
    679    NULL,
    680 };
    681 
    682 #include "compiler/nir/nir_search_helpers.h"
    683 static const nir_search_variable search237_1_1 = {
    684    { nir_search_value_variable, 0 },
    685    0, /* a */
    686    false,
    687    nir_type_invalid,
    688    NULL,
    689 };
    690 #include "compiler/nir/nir_search_helpers.h"
    691 static const nir_search_expression search237_1 = {
    692    { nir_search_value_expression, 0 },
    693    false,
    694    nir_op_flt,
    695    { &search237_1_0.value, &search237_1_1.value },
    696    NULL,
    697 };
    698 #include "compiler/nir/nir_search_helpers.h"
    699 static const nir_search_expression search237 = {
    700    { nir_search_value_expression, 0 },
    701    false,
    702    nir_op_iand,
    703    { &search237_0.value, &search237_1.value },
    704    NULL,
    705 };
    706 
    707 #include "compiler/nir/nir_search_helpers.h"
    708 static const nir_search_variable replace237_0 = {
    709    { nir_search_value_variable, 0 },
    710    1, /* b */
    711    false,
    712    nir_type_invalid,
    713    NULL,
    714 };
    715 
    716 #include "compiler/nir/nir_search_helpers.h"
    717 static const nir_search_variable replace237_1 = {
    718    { nir_search_value_variable, 0 },
    719    0, /* a */
    720    false,
    721    nir_type_invalid,
    722    NULL,
    723 };
    724 #include "compiler/nir/nir_search_helpers.h"
    725 static const nir_search_expression replace237 = {
    726    { nir_search_value_expression, 0 },
    727    false,
    728    nir_op_flt,
    729    { &replace237_0.value, &replace237_1.value },
    730    NULL,
    731 };
    732 
    733 #include "compiler/nir/nir_search_helpers.h"
    734 static const nir_search_variable search238_0_0 = {
    735    { nir_search_value_variable, 0 },
    736    0, /* a */
    737    false,
    738    nir_type_invalid,
    739    NULL,
    740 };
    741 
    742 #include "compiler/nir/nir_search_helpers.h"
    743 static const nir_search_variable search238_0_1 = {
    744    { nir_search_value_variable, 0 },
    745    0, /* a */
    746    false,
    747    nir_type_invalid,
    748    NULL,
    749 };
    750 #include "compiler/nir/nir_search_helpers.h"
    751 static const nir_search_expression search238_0 = {
    752    { nir_search_value_expression, 0 },
    753    false,
    754    nir_op_feq,
    755    { &search238_0_0.value, &search238_0_1.value },
    756    NULL,
    757 };
    758 
    759 #include "compiler/nir/nir_search_helpers.h"
    760 static const nir_search_variable search238_1_0 = {
    761    { nir_search_value_variable, 0 },
    762    0, /* a */
    763    false,
    764    nir_type_invalid,
    765    NULL,
    766 };
    767 
    768 #include "compiler/nir/nir_search_helpers.h"
    769 static const nir_search_variable search238_1_1 = {
    770    { nir_search_value_variable, 0 },
    771    1, /* b */
    772    false,
    773    nir_type_invalid,
    774    NULL,
    775 };
    776 #include "compiler/nir/nir_search_helpers.h"
    777 static const nir_search_expression search238_1 = {
    778    { nir_search_value_expression, 0 },
    779    false,
    780    nir_op_fge,
    781    { &search238_1_0.value, &search238_1_1.value },
    782    NULL,
    783 };
    784 #include "compiler/nir/nir_search_helpers.h"
    785 static const nir_search_expression search238 = {
    786    { nir_search_value_expression, 0 },
    787    false,
    788    nir_op_iand,
    789    { &search238_0.value, &search238_1.value },
    790    NULL,
    791 };
    792 
    793 #include "compiler/nir/nir_search_helpers.h"
    794 static const nir_search_variable replace238_0 = {
    795    { nir_search_value_variable, 0 },
    796    0, /* a */
    797    false,
    798    nir_type_invalid,
    799    NULL,
    800 };
    801 
    802 #include "compiler/nir/nir_search_helpers.h"
    803 static const nir_search_variable replace238_1 = {
    804    { nir_search_value_variable, 0 },
    805    1, /* b */
    806    false,
    807    nir_type_invalid,
    808    NULL,
    809 };
    810 #include "compiler/nir/nir_search_helpers.h"
    811 static const nir_search_expression replace238 = {
    812    { nir_search_value_expression, 0 },
    813    false,
    814    nir_op_fge,
    815    { &replace238_0.value, &replace238_1.value },
    816    NULL,
    817 };
    818 
    819 #include "compiler/nir/nir_search_helpers.h"
    820 static const nir_search_variable search239_0_0 = {
    821    { nir_search_value_variable, 0 },
    822    0, /* a */
    823    false,
    824    nir_type_invalid,
    825    NULL,
    826 };
    827 
    828 #include "compiler/nir/nir_search_helpers.h"
    829 static const nir_search_variable search239_0_1 = {
    830    { nir_search_value_variable, 0 },
    831    0, /* a */
    832    false,
    833    nir_type_invalid,
    834    NULL,
    835 };
    836 #include "compiler/nir/nir_search_helpers.h"
    837 static const nir_search_expression search239_0 = {
    838    { nir_search_value_expression, 0 },
    839    false,
    840    nir_op_feq,
    841    { &search239_0_0.value, &search239_0_1.value },
    842    NULL,
    843 };
    844 
    845 #include "compiler/nir/nir_search_helpers.h"
    846 static const nir_search_variable search239_1_0 = {
    847    { nir_search_value_variable, 0 },
    848    1, /* b */
    849    false,
    850    nir_type_invalid,
    851    NULL,
    852 };
    853 
    854 #include "compiler/nir/nir_search_helpers.h"
    855 static const nir_search_variable search239_1_1 = {
    856    { nir_search_value_variable, 0 },
    857    0, /* a */
    858    false,
    859    nir_type_invalid,
    860    NULL,
    861 };
    862 #include "compiler/nir/nir_search_helpers.h"
    863 static const nir_search_expression search239_1 = {
    864    { nir_search_value_expression, 0 },
    865    false,
    866    nir_op_fge,
    867    { &search239_1_0.value, &search239_1_1.value },
    868    NULL,
    869 };
    870 #include "compiler/nir/nir_search_helpers.h"
    871 static const nir_search_expression search239 = {
    872    { nir_search_value_expression, 0 },
    873    false,
    874    nir_op_iand,
    875    { &search239_0.value, &search239_1.value },
    876    NULL,
    877 };
    878 
    879 #include "compiler/nir/nir_search_helpers.h"
    880 static const nir_search_variable replace239_0 = {
    881    { nir_search_value_variable, 0 },
    882    1, /* b */
    883    false,
    884    nir_type_invalid,
    885    NULL,
    886 };
    887 
    888 #include "compiler/nir/nir_search_helpers.h"
    889 static const nir_search_variable replace239_1 = {
    890    { nir_search_value_variable, 0 },
    891    0, /* a */
    892    false,
    893    nir_type_invalid,
    894    NULL,
    895 };
    896 #include "compiler/nir/nir_search_helpers.h"
    897 static const nir_search_expression replace239 = {
    898    { nir_search_value_expression, 0 },
    899    false,
    900    nir_op_fge,
    901    { &replace239_0.value, &replace239_1.value },
    902    NULL,
    903 };
    904 
    905 #include "compiler/nir/nir_search_helpers.h"
    906 static const nir_search_variable search240_0_0 = {
    907    { nir_search_value_variable, 0 },
    908    0, /* a */
    909    false,
    910    nir_type_invalid,
    911    NULL,
    912 };
    913 
    914 #include "compiler/nir/nir_search_helpers.h"
    915 static const nir_search_variable search240_0_1 = {
    916    { nir_search_value_variable, 0 },
    917    0, /* a */
    918    false,
    919    nir_type_invalid,
    920    NULL,
    921 };
    922 #include "compiler/nir/nir_search_helpers.h"
    923 static const nir_search_expression search240_0 = {
    924    { nir_search_value_expression, 0 },
    925    false,
    926    nir_op_feq,
    927    { &search240_0_0.value, &search240_0_1.value },
    928    NULL,
    929 };
    930 
    931 #include "compiler/nir/nir_search_helpers.h"
    932 static const nir_search_variable search240_1_0 = {
    933    { nir_search_value_variable, 0 },
    934    0, /* a */
    935    false,
    936    nir_type_invalid,
    937    NULL,
    938 };
    939 
    940 #include "compiler/nir/nir_search_helpers.h"
    941 static const nir_search_variable search240_1_1 = {
    942    { nir_search_value_variable, 0 },
    943    1, /* b */
    944    false,
    945    nir_type_invalid,
    946    NULL,
    947 };
    948 #include "compiler/nir/nir_search_helpers.h"
    949 static const nir_search_expression search240_1 = {
    950    { nir_search_value_expression, 0 },
    951    false,
    952    nir_op_feq,
    953    { &search240_1_0.value, &search240_1_1.value },
    954    NULL,
    955 };
    956 #include "compiler/nir/nir_search_helpers.h"
    957 static const nir_search_expression search240 = {
    958    { nir_search_value_expression, 0 },
    959    false,
    960    nir_op_iand,
    961    { &search240_0.value, &search240_1.value },
    962    NULL,
    963 };
    964 
    965 #include "compiler/nir/nir_search_helpers.h"
    966 static const nir_search_variable replace240_0 = {
    967    { nir_search_value_variable, 0 },
    968    0, /* a */
    969    false,
    970    nir_type_invalid,
    971    NULL,
    972 };
    973 
    974 #include "compiler/nir/nir_search_helpers.h"
    975 static const nir_search_variable replace240_1 = {
    976    { nir_search_value_variable, 0 },
    977    1, /* b */
    978    false,
    979    nir_type_invalid,
    980    NULL,
    981 };
    982 #include "compiler/nir/nir_search_helpers.h"
    983 static const nir_search_expression replace240 = {
    984    { nir_search_value_expression, 0 },
    985    false,
    986    nir_op_feq,
    987    { &replace240_0.value, &replace240_1.value },
    988    NULL,
    989 };
    990 
    991 #include "compiler/nir/nir_search_helpers.h"
    992 static const nir_search_variable search241_0_0 = {
    993    { nir_search_value_variable, 0 },
    994    0, /* a */
    995    false,
    996    nir_type_invalid,
    997    NULL,
    998 };
    999 
   1000 #include "compiler/nir/nir_search_helpers.h"
   1001 static const nir_search_variable search241_0_1 = {
   1002    { nir_search_value_variable, 0 },
   1003    0, /* a */
   1004    false,
   1005    nir_type_invalid,
   1006    NULL,
   1007 };
   1008 #include "compiler/nir/nir_search_helpers.h"
   1009 static const nir_search_expression search241_0 = {
   1010    { nir_search_value_expression, 0 },
   1011    false,
   1012    nir_op_feq,
   1013    { &search241_0_0.value, &search241_0_1.value },
   1014    NULL,
   1015 };
   1016 
   1017 #include "compiler/nir/nir_search_helpers.h"
   1018 static const nir_search_variable search241_1_0 = {
   1019    { nir_search_value_variable, 0 },
   1020    1, /* b */
   1021    false,
   1022    nir_type_invalid,
   1023    NULL,
   1024 };
   1025 
   1026 #include "compiler/nir/nir_search_helpers.h"
   1027 static const nir_search_variable search241_1_1 = {
   1028    { nir_search_value_variable, 0 },
   1029    0, /* a */
   1030    false,
   1031    nir_type_invalid,
   1032    NULL,
   1033 };
   1034 #include "compiler/nir/nir_search_helpers.h"
   1035 static const nir_search_expression search241_1 = {
   1036    { nir_search_value_expression, 0 },
   1037    false,
   1038    nir_op_feq,
   1039    { &search241_1_0.value, &search241_1_1.value },
   1040    NULL,
   1041 };
   1042 #include "compiler/nir/nir_search_helpers.h"
   1043 static const nir_search_expression search241 = {
   1044    { nir_search_value_expression, 0 },
   1045    false,
   1046    nir_op_iand,
   1047    { &search241_0.value, &search241_1.value },
   1048    NULL,
   1049 };
   1050 
   1051 #include "compiler/nir/nir_search_helpers.h"
   1052 static const nir_search_variable replace241_0 = {
   1053    { nir_search_value_variable, 0 },
   1054    1, /* b */
   1055    false,
   1056    nir_type_invalid,
   1057    NULL,
   1058 };
   1059 
   1060 #include "compiler/nir/nir_search_helpers.h"
   1061 static const nir_search_variable replace241_1 = {
   1062    { nir_search_value_variable, 0 },
   1063    0, /* a */
   1064    false,
   1065    nir_type_invalid,
   1066    NULL,
   1067 };
   1068 #include "compiler/nir/nir_search_helpers.h"
   1069 static const nir_search_expression replace241 = {
   1070    { nir_search_value_expression, 0 },
   1071    false,
   1072    nir_op_feq,
   1073    { &replace241_0.value, &replace241_1.value },
   1074    NULL,
   1075 };
   1076 
   1077 static const struct transform nir_opt_algebraic_iand_xforms[] = {
   1078    { &search111, &replace111.value, 0 },
   1079    { &search122, &replace122.value, 0 },
   1080    { &search123, &replace123.value, 0 },
   1081    { &search124, &replace124.value, 0 },
   1082    { &search132, &replace132.value, 0 },
   1083    { &search140, &replace140.value, 0 },
   1084    { &search141, &replace141.value, 0 },
   1085    { &search190, &replace190.value, 17 },
   1086    { &search191, &replace191.value, 17 },
   1087    { &search192, &replace192.value, 17 },
   1088    { &search194, &replace194.value, 18 },
   1089    { &search236, &replace236.value, 0 },
   1090    { &search237, &replace237.value, 0 },
   1091    { &search238, &replace238.value, 0 },
   1092    { &search239, &replace239.value, 0 },
   1093    { &search240, &replace240.value, 0 },
   1094    { &search241, &replace241.value, 0 },
   1095 };
   1096 
   1097 #include "compiler/nir/nir_search_helpers.h"
   1098 static const nir_search_variable search182_0_0 = {
   1099    { nir_search_value_variable, 0 },
   1100    0, /* a */
   1101    false,
   1102    nir_type_invalid,
   1103    NULL,
   1104 };
   1105 #include "compiler/nir/nir_search_helpers.h"
   1106 static const nir_search_expression search182_0 = {
   1107    { nir_search_value_expression, 0 },
   1108    false,
   1109    nir_op_b2i,
   1110    { &search182_0_0.value },
   1111    NULL,
   1112 };
   1113 #include "compiler/nir/nir_search_helpers.h"
   1114 static const nir_search_expression search182 = {
   1115    { nir_search_value_expression, 0 },
   1116    false,
   1117    nir_op_i2b,
   1118    { &search182_0.value },
   1119    NULL,
   1120 };
   1121 
   1122 #include "compiler/nir/nir_search_helpers.h"
   1123 static const nir_search_variable replace182 = {
   1124    { nir_search_value_variable, 0 },
   1125    0, /* a */
   1126    false,
   1127    nir_type_invalid,
   1128    NULL,
   1129 };
   1130 
   1131 #include "compiler/nir/nir_search_helpers.h"
   1132 static const nir_search_variable search185_0_0 = {
   1133    { nir_search_value_variable, 0 },
   1134    0, /* a */
   1135    false,
   1136    nir_type_invalid,
   1137    NULL,
   1138 };
   1139 #include "compiler/nir/nir_search_helpers.h"
   1140 static const nir_search_expression search185_0 = {
   1141    { nir_search_value_expression, 0 },
   1142    false,
   1143    nir_op_ineg,
   1144    { &search185_0_0.value },
   1145    NULL,
   1146 };
   1147 #include "compiler/nir/nir_search_helpers.h"
   1148 static const nir_search_expression search185 = {
   1149    { nir_search_value_expression, 0 },
   1150    false,
   1151    nir_op_i2b,
   1152    { &search185_0.value },
   1153    NULL,
   1154 };
   1155 
   1156 #include "compiler/nir/nir_search_helpers.h"
   1157 static const nir_search_variable replace185_0 = {
   1158    { nir_search_value_variable, 0 },
   1159    0, /* a */
   1160    false,
   1161    nir_type_invalid,
   1162    NULL,
   1163 };
   1164 #include "compiler/nir/nir_search_helpers.h"
   1165 static const nir_search_expression replace185 = {
   1166    { nir_search_value_expression, 0 },
   1167    false,
   1168    nir_op_i2b,
   1169    { &replace185_0.value },
   1170    NULL,
   1171 };
   1172 
   1173 #include "compiler/nir/nir_search_helpers.h"
   1174 static const nir_search_variable search186_0_0 = {
   1175    { nir_search_value_variable, 0 },
   1176    0, /* a */
   1177    false,
   1178    nir_type_invalid,
   1179    NULL,
   1180 };
   1181 #include "compiler/nir/nir_search_helpers.h"
   1182 static const nir_search_expression search186_0 = {
   1183    { nir_search_value_expression, 0 },
   1184    false,
   1185    nir_op_iabs,
   1186    { &search186_0_0.value },
   1187    NULL,
   1188 };
   1189 #include "compiler/nir/nir_search_helpers.h"
   1190 static const nir_search_expression search186 = {
   1191    { nir_search_value_expression, 0 },
   1192    false,
   1193    nir_op_i2b,
   1194    { &search186_0.value },
   1195    NULL,
   1196 };
   1197 
   1198 #include "compiler/nir/nir_search_helpers.h"
   1199 static const nir_search_variable replace186_0 = {
   1200    { nir_search_value_variable, 0 },
   1201    0, /* a */
   1202    false,
   1203    nir_type_invalid,
   1204    NULL,
   1205 };
   1206 #include "compiler/nir/nir_search_helpers.h"
   1207 static const nir_search_expression replace186 = {
   1208    { nir_search_value_expression, 0 },
   1209    false,
   1210    nir_op_i2b,
   1211    { &replace186_0.value },
   1212    NULL,
   1213 };
   1214 
   1215 static const struct transform nir_opt_algebraic_i2b_xforms[] = {
   1216    { &search182, &replace182.value, 0 },
   1217    { &search185, &replace185.value, 0 },
   1218    { &search186, &replace186.value, 0 },
   1219 };
   1220 
   1221 #include "compiler/nir/nir_search_helpers.h"
   1222 static const nir_search_variable search129_0 = {
   1223    { nir_search_value_variable, 0 },
   1224    0, /* a */
   1225    false,
   1226    nir_type_invalid,
   1227    NULL,
   1228 };
   1229 
   1230 #include "compiler/nir/nir_search_helpers.h"
   1231 static const nir_search_variable search129_1 = {
   1232    { nir_search_value_variable, 0 },
   1233    0, /* a */
   1234    false,
   1235    nir_type_invalid,
   1236    NULL,
   1237 };
   1238 #include "compiler/nir/nir_search_helpers.h"
   1239 static const nir_search_expression search129 = {
   1240    { nir_search_value_expression, 0 },
   1241    false,
   1242    nir_op_ixor,
   1243    { &search129_0.value, &search129_1.value },
   1244    NULL,
   1245 };
   1246 
   1247 #include "compiler/nir/nir_search_helpers.h"
   1248 static const nir_search_constant replace129 = {
   1249    { nir_search_value_constant, 0 },
   1250    nir_type_int, { 0x0 /* 0 */ },
   1251 };
   1252 
   1253 #include "compiler/nir/nir_search_helpers.h"
   1254 static const nir_search_variable search130_0 = {
   1255    { nir_search_value_variable, 0 },
   1256    0, /* a */
   1257    false,
   1258    nir_type_invalid,
   1259    NULL,
   1260 };
   1261 
   1262 #include "compiler/nir/nir_search_helpers.h"
   1263 static const nir_search_constant search130_1 = {
   1264    { nir_search_value_constant, 0 },
   1265    nir_type_int, { 0x0 /* 0 */ },
   1266 };
   1267 #include "compiler/nir/nir_search_helpers.h"
   1268 static const nir_search_expression search130 = {
   1269    { nir_search_value_expression, 0 },
   1270    false,
   1271    nir_op_ixor,
   1272    { &search130_0.value, &search130_1.value },
   1273    NULL,
   1274 };
   1275 
   1276 #include "compiler/nir/nir_search_helpers.h"
   1277 static const nir_search_variable replace130 = {
   1278    { nir_search_value_variable, 0 },
   1279    0, /* a */
   1280    false,
   1281    nir_type_invalid,
   1282    NULL,
   1283 };
   1284 
   1285 static const struct transform nir_opt_algebraic_ixor_xforms[] = {
   1286    { &search129, &replace129.value, 0 },
   1287    { &search130, &replace130.value, 0 },
   1288 };
   1289 
   1290 #include "compiler/nir/nir_search_helpers.h"
   1291 static const nir_search_variable search104_0 = {
   1292    { nir_search_value_variable, 0 },
   1293    0, /* a */
   1294    false,
   1295    nir_type_invalid,
   1296    NULL,
   1297 };
   1298 
   1299 #include "compiler/nir/nir_search_helpers.h"
   1300 static const nir_search_variable search104_1 = {
   1301    { nir_search_value_variable, 0 },
   1302    1, /* b */
   1303    false,
   1304    nir_type_invalid,
   1305    NULL,
   1306 };
   1307 #include "compiler/nir/nir_search_helpers.h"
   1308 static const nir_search_expression search104 = {
   1309    { nir_search_value_expression, 0 },
   1310    false,
   1311    nir_op_seq,
   1312    { &search104_0.value, &search104_1.value },
   1313    NULL,
   1314 };
   1315 
   1316 #include "compiler/nir/nir_search_helpers.h"
   1317 static const nir_search_variable replace104_0_0 = {
   1318    { nir_search_value_variable, 0 },
   1319    0, /* a */
   1320    false,
   1321    nir_type_invalid,
   1322    NULL,
   1323 };
   1324 
   1325 #include "compiler/nir/nir_search_helpers.h"
   1326 static const nir_search_variable replace104_0_1 = {
   1327    { nir_search_value_variable, 0 },
   1328    1, /* b */
   1329    false,
   1330    nir_type_invalid,
   1331    NULL,
   1332 };
   1333 #include "compiler/nir/nir_search_helpers.h"
   1334 static const nir_search_expression replace104_0 = {
   1335    { nir_search_value_expression, 0 },
   1336    false,
   1337    nir_op_feq,
   1338    { &replace104_0_0.value, &replace104_0_1.value },
   1339    NULL,
   1340 };
   1341 #include "compiler/nir/nir_search_helpers.h"
   1342 static const nir_search_expression replace104 = {
   1343    { nir_search_value_expression, 0 },
   1344    false,
   1345    nir_op_b2f,
   1346    { &replace104_0.value },
   1347    NULL,
   1348 };
   1349 
   1350 static const struct transform nir_opt_algebraic_seq_xforms[] = {
   1351    { &search104, &replace104.value, 11 },
   1352 };
   1353 
   1354 #include "compiler/nir/nir_search_helpers.h"
   1355 static const nir_search_variable search115_0 = {
   1356    { nir_search_value_variable, 0 },
   1357    0, /* a */
   1358    false,
   1359    nir_type_invalid,
   1360    NULL,
   1361 };
   1362 
   1363 #include "compiler/nir/nir_search_helpers.h"
   1364 static const nir_search_variable search115_1 = {
   1365    { nir_search_value_variable, 0 },
   1366    0, /* a */
   1367    false,
   1368    nir_type_invalid,
   1369    NULL,
   1370 };
   1371 #include "compiler/nir/nir_search_helpers.h"
   1372 static const nir_search_expression search115 = {
   1373    { nir_search_value_expression, 0 },
   1374    false,
   1375    nir_op_ilt,
   1376    { &search115_0.value, &search115_1.value },
   1377    NULL,
   1378 };
   1379 
   1380 #include "compiler/nir/nir_search_helpers.h"
   1381 static const nir_search_constant replace115 = {
   1382    { nir_search_value_constant, 32 },
   1383    nir_type_bool32, { NIR_FALSE /* False */ },
   1384 };
   1385 
   1386 #include "compiler/nir/nir_search_helpers.h"
   1387 static const nir_search_variable search250_0_0 = {
   1388    { nir_search_value_variable, 0 },
   1389    0, /* a */
   1390    false,
   1391    nir_type_invalid,
   1392    NULL,
   1393 };
   1394 
   1395 #include "compiler/nir/nir_search_helpers.h"
   1396 static const nir_search_variable search250_0_1 = {
   1397    { nir_search_value_variable, 0 },
   1398    1, /* b */
   1399    true,
   1400    nir_type_invalid,
   1401    NULL,
   1402 };
   1403 
   1404 #include "compiler/nir/nir_search_helpers.h"
   1405 static const nir_search_variable search250_0_2 = {
   1406    { nir_search_value_variable, 0 },
   1407    2, /* c */
   1408    true,
   1409    nir_type_invalid,
   1410    NULL,
   1411 };
   1412 #include "compiler/nir/nir_search_helpers.h"
   1413 static const nir_search_expression search250_0 = {
   1414    { nir_search_value_expression, 0 },
   1415    false,
   1416    nir_op_bcsel,
   1417    { &search250_0_0.value, &search250_0_1.value, &search250_0_2.value },
   1418    NULL,
   1419 };
   1420 
   1421 #include "compiler/nir/nir_search_helpers.h"
   1422 static const nir_search_variable search250_1 = {
   1423    { nir_search_value_variable, 0 },
   1424    3, /* d */
   1425    true,
   1426    nir_type_invalid,
   1427    NULL,
   1428 };
   1429 #include "compiler/nir/nir_search_helpers.h"
   1430 static const nir_search_expression search250 = {
   1431    { nir_search_value_expression, 0 },
   1432    false,
   1433    nir_op_ilt,
   1434    { &search250_0.value, &search250_1.value },
   1435    NULL,
   1436 };
   1437 
   1438 #include "compiler/nir/nir_search_helpers.h"
   1439 static const nir_search_variable replace250_0 = {
   1440    { nir_search_value_variable, 0 },
   1441    0, /* a */
   1442    false,
   1443    nir_type_invalid,
   1444    NULL,
   1445 };
   1446 
   1447 #include "compiler/nir/nir_search_helpers.h"
   1448 static const nir_search_variable replace250_1_0 = {
   1449    { nir_search_value_variable, 0 },
   1450    1, /* b */
   1451    false,
   1452    nir_type_invalid,
   1453    NULL,
   1454 };
   1455 
   1456 #include "compiler/nir/nir_search_helpers.h"
   1457 static const nir_search_variable replace250_1_1 = {
   1458    { nir_search_value_variable, 0 },
   1459    3, /* d */
   1460    false,
   1461    nir_type_invalid,
   1462    NULL,
   1463 };
   1464 #include "compiler/nir/nir_search_helpers.h"
   1465 static const nir_search_expression replace250_1 = {
   1466    { nir_search_value_expression, 0 },
   1467    false,
   1468    nir_op_ilt,
   1469    { &replace250_1_0.value, &replace250_1_1.value },
   1470    NULL,
   1471 };
   1472 
   1473 #include "compiler/nir/nir_search_helpers.h"
   1474 static const nir_search_variable replace250_2_0 = {
   1475    { nir_search_value_variable, 0 },
   1476    2, /* c */
   1477    false,
   1478    nir_type_invalid,
   1479    NULL,
   1480 };
   1481 
   1482 #include "compiler/nir/nir_search_helpers.h"
   1483 static const nir_search_variable replace250_2_1 = {
   1484    { nir_search_value_variable, 0 },
   1485    3, /* d */
   1486    false,
   1487    nir_type_invalid,
   1488    NULL,
   1489 };
   1490 #include "compiler/nir/nir_search_helpers.h"
   1491 static const nir_search_expression replace250_2 = {
   1492    { nir_search_value_expression, 0 },
   1493    false,
   1494    nir_op_ilt,
   1495    { &replace250_2_0.value, &replace250_2_1.value },
   1496    NULL,
   1497 };
   1498 #include "compiler/nir/nir_search_helpers.h"
   1499 static const nir_search_expression replace250 = {
   1500    { nir_search_value_expression, 0 },
   1501    false,
   1502    nir_op_bcsel,
   1503    { &replace250_0.value, &replace250_1.value, &replace250_2.value },
   1504    NULL,
   1505 };
   1506 
   1507 #include "compiler/nir/nir_search_helpers.h"
   1508 static const nir_search_variable search251_0 = {
   1509    { nir_search_value_variable, 0 },
   1510    0, /* d */
   1511    true,
   1512    nir_type_invalid,
   1513    NULL,
   1514 };
   1515 
   1516 #include "compiler/nir/nir_search_helpers.h"
   1517 static const nir_search_variable search251_1_0 = {
   1518    { nir_search_value_variable, 0 },
   1519    1, /* a */
   1520    false,
   1521    nir_type_invalid,
   1522    NULL,
   1523 };
   1524 
   1525 #include "compiler/nir/nir_search_helpers.h"
   1526 static const nir_search_variable search251_1_1 = {
   1527    { nir_search_value_variable, 0 },
   1528    2, /* b */
   1529    true,
   1530    nir_type_invalid,
   1531    NULL,
   1532 };
   1533 
   1534 #include "compiler/nir/nir_search_helpers.h"
   1535 static const nir_search_variable search251_1_2 = {
   1536    { nir_search_value_variable, 0 },
   1537    3, /* c */
   1538    true,
   1539    nir_type_invalid,
   1540    NULL,
   1541 };
   1542 #include "compiler/nir/nir_search_helpers.h"
   1543 static const nir_search_expression search251_1 = {
   1544    { nir_search_value_expression, 0 },
   1545    false,
   1546    nir_op_bcsel,
   1547    { &search251_1_0.value, &search251_1_1.value, &search251_1_2.value },
   1548    NULL,
   1549 };
   1550 #include "compiler/nir/nir_search_helpers.h"
   1551 static const nir_search_expression search251 = {
   1552    { nir_search_value_expression, 0 },
   1553    false,
   1554    nir_op_ilt,
   1555    { &search251_0.value, &search251_1.value },
   1556    NULL,
   1557 };
   1558 
   1559 #include "compiler/nir/nir_search_helpers.h"
   1560 static const nir_search_variable replace251_0 = {
   1561    { nir_search_value_variable, 0 },
   1562    1, /* a */
   1563    false,
   1564    nir_type_invalid,
   1565    NULL,
   1566 };
   1567 
   1568 #include "compiler/nir/nir_search_helpers.h"
   1569 static const nir_search_variable replace251_1_0 = {
   1570    { nir_search_value_variable, 0 },
   1571    0, /* d */
   1572    false,
   1573    nir_type_invalid,
   1574    NULL,
   1575 };
   1576 
   1577 #include "compiler/nir/nir_search_helpers.h"
   1578 static const nir_search_variable replace251_1_1 = {
   1579    { nir_search_value_variable, 0 },
   1580    2, /* b */
   1581    false,
   1582    nir_type_invalid,
   1583    NULL,
   1584 };
   1585 #include "compiler/nir/nir_search_helpers.h"
   1586 static const nir_search_expression replace251_1 = {
   1587    { nir_search_value_expression, 0 },
   1588    false,
   1589    nir_op_ilt,
   1590    { &replace251_1_0.value, &replace251_1_1.value },
   1591    NULL,
   1592 };
   1593 
   1594 #include "compiler/nir/nir_search_helpers.h"
   1595 static const nir_search_variable replace251_2_0 = {
   1596    { nir_search_value_variable, 0 },
   1597    0, /* d */
   1598    false,
   1599    nir_type_invalid,
   1600    NULL,
   1601 };
   1602 
   1603 #include "compiler/nir/nir_search_helpers.h"
   1604 static const nir_search_variable replace251_2_1 = {
   1605    { nir_search_value_variable, 0 },
   1606    3, /* c */
   1607    false,
   1608    nir_type_invalid,
   1609    NULL,
   1610 };
   1611 #include "compiler/nir/nir_search_helpers.h"
   1612 static const nir_search_expression replace251_2 = {
   1613    { nir_search_value_expression, 0 },
   1614    false,
   1615    nir_op_ilt,
   1616    { &replace251_2_0.value, &replace251_2_1.value },
   1617    NULL,
   1618 };
   1619 #include "compiler/nir/nir_search_helpers.h"
   1620 static const nir_search_expression replace251 = {
   1621    { nir_search_value_expression, 0 },
   1622    false,
   1623    nir_op_bcsel,
   1624    { &replace251_0.value, &replace251_1.value, &replace251_2.value },
   1625    NULL,
   1626 };
   1627 
   1628 static const struct transform nir_opt_algebraic_ilt_xforms[] = {
   1629    { &search115, &replace115.value, 0 },
   1630    { &search250, &replace250.value, 0 },
   1631    { &search251, &replace251.value, 0 },
   1632 };
   1633 
   1634 #include "compiler/nir/nir_search_helpers.h"
   1635 static const nir_search_variable search4_0 = {
   1636    { nir_search_value_variable, 0 },
   1637    0, /* a */
   1638    false,
   1639    nir_type_invalid,
   1640    NULL,
   1641 };
   1642 
   1643 #include "compiler/nir/nir_search_helpers.h"
   1644 static const nir_search_constant search4_1 = {
   1645    { nir_search_value_constant, 0 },
   1646    nir_type_int, { 0x1 /* 1 */ },
   1647 };
   1648 #include "compiler/nir/nir_search_helpers.h"
   1649 static const nir_search_expression search4 = {
   1650    { nir_search_value_expression, 0 },
   1651    false,
   1652    nir_op_umod,
   1653    { &search4_0.value, &search4_1.value },
   1654    NULL,
   1655 };
   1656 
   1657 #include "compiler/nir/nir_search_helpers.h"
   1658 static const nir_search_constant replace4 = {
   1659    { nir_search_value_constant, 0 },
   1660    nir_type_int, { 0x0 /* 0 */ },
   1661 };
   1662 
   1663 #include "compiler/nir/nir_search_helpers.h"
   1664 static const nir_search_variable search9_0 = {
   1665    { nir_search_value_variable, 0 },
   1666    0, /* a */
   1667    false,
   1668    nir_type_invalid,
   1669    NULL,
   1670 };
   1671 
   1672 #include "compiler/nir/nir_search_helpers.h"
   1673 static const nir_search_variable search9_1 = {
   1674    { nir_search_value_variable, 0 },
   1675    1, /* b */
   1676    true,
   1677    nir_type_invalid,
   1678    (is_pos_power_of_two),
   1679 };
   1680 #include "compiler/nir/nir_search_helpers.h"
   1681 static const nir_search_expression search9 = {
   1682    { nir_search_value_expression, 0 },
   1683    false,
   1684    nir_op_umod,
   1685    { &search9_0.value, &search9_1.value },
   1686    NULL,
   1687 };
   1688 
   1689 #include "compiler/nir/nir_search_helpers.h"
   1690 static const nir_search_variable replace9_0 = {
   1691    { nir_search_value_variable, 0 },
   1692    0, /* a */
   1693    false,
   1694    nir_type_invalid,
   1695    NULL,
   1696 };
   1697 
   1698 #include "compiler/nir/nir_search_helpers.h"
   1699 static const nir_search_variable replace9_1_0 = {
   1700    { nir_search_value_variable, 0 },
   1701    1, /* b */
   1702    false,
   1703    nir_type_invalid,
   1704    NULL,
   1705 };
   1706 
   1707 #include "compiler/nir/nir_search_helpers.h"
   1708 static const nir_search_constant replace9_1_1 = {
   1709    { nir_search_value_constant, 0 },
   1710    nir_type_int, { 0x1 /* 1 */ },
   1711 };
   1712 #include "compiler/nir/nir_search_helpers.h"
   1713 static const nir_search_expression replace9_1 = {
   1714    { nir_search_value_expression, 0 },
   1715    false,
   1716    nir_op_isub,
   1717    { &replace9_1_0.value, &replace9_1_1.value },
   1718    NULL,
   1719 };
   1720 #include "compiler/nir/nir_search_helpers.h"
   1721 static const nir_search_expression replace9 = {
   1722    { nir_search_value_expression, 0 },
   1723    false,
   1724    nir_op_iand,
   1725    { &replace9_0.value, &replace9_1.value },
   1726    NULL,
   1727 };
   1728 
   1729 static const struct transform nir_opt_algebraic_umod_xforms[] = {
   1730    { &search4, &replace4.value, 0 },
   1731    { &search9, &replace9.value, 0 },
   1732 };
   1733 
   1734 #include "compiler/nir/nir_search_helpers.h"
   1735 static const nir_search_variable search0_0 = {
   1736    { nir_search_value_variable, 0 },
   1737    0, /* a */
   1738    false,
   1739    nir_type_invalid,
   1740    NULL,
   1741 };
   1742 
   1743 #include "compiler/nir/nir_search_helpers.h"
   1744 static const nir_search_variable search0_1 = {
   1745    { nir_search_value_variable, 32 },
   1746    1, /* b */
   1747    true,
   1748    nir_type_invalid,
   1749    (is_pos_power_of_two),
   1750 };
   1751 #include "compiler/nir/nir_search_helpers.h"
   1752 static const nir_search_expression search0 = {
   1753    { nir_search_value_expression, 0 },
   1754    false,
   1755    nir_op_imul,
   1756    { &search0_0.value, &search0_1.value },
   1757    NULL,
   1758 };
   1759 
   1760 #include "compiler/nir/nir_search_helpers.h"
   1761 static const nir_search_variable replace0_0 = {
   1762    { nir_search_value_variable, 0 },
   1763    0, /* a */
   1764    false,
   1765    nir_type_invalid,
   1766    NULL,
   1767 };
   1768 
   1769 #include "compiler/nir/nir_search_helpers.h"
   1770 static const nir_search_variable replace0_1_0 = {
   1771    { nir_search_value_variable, 0 },
   1772    1, /* b */
   1773    false,
   1774    nir_type_invalid,
   1775    NULL,
   1776 };
   1777 #include "compiler/nir/nir_search_helpers.h"
   1778 static const nir_search_expression replace0_1 = {
   1779    { nir_search_value_expression, 0 },
   1780    false,
   1781    nir_op_find_lsb,
   1782    { &replace0_1_0.value },
   1783    NULL,
   1784 };
   1785 #include "compiler/nir/nir_search_helpers.h"
   1786 static const nir_search_expression replace0 = {
   1787    { nir_search_value_expression, 0 },
   1788    false,
   1789    nir_op_ishl,
   1790    { &replace0_0.value, &replace0_1.value },
   1791    NULL,
   1792 };
   1793 
   1794 #include "compiler/nir/nir_search_helpers.h"
   1795 static const nir_search_variable search1_0 = {
   1796    { nir_search_value_variable, 0 },
   1797    0, /* a */
   1798    false,
   1799    nir_type_invalid,
   1800    NULL,
   1801 };
   1802 
   1803 #include "compiler/nir/nir_search_helpers.h"
   1804 static const nir_search_variable search1_1 = {
   1805    { nir_search_value_variable, 32 },
   1806    1, /* b */
   1807    true,
   1808    nir_type_invalid,
   1809    (is_neg_power_of_two),
   1810 };
   1811 #include "compiler/nir/nir_search_helpers.h"
   1812 static const nir_search_expression search1 = {
   1813    { nir_search_value_expression, 0 },
   1814    false,
   1815    nir_op_imul,
   1816    { &search1_0.value, &search1_1.value },
   1817    NULL,
   1818 };
   1819 
   1820 #include "compiler/nir/nir_search_helpers.h"
   1821 static const nir_search_variable replace1_0_0 = {
   1822    { nir_search_value_variable, 0 },
   1823    0, /* a */
   1824    false,
   1825    nir_type_invalid,
   1826    NULL,
   1827 };
   1828 
   1829 #include "compiler/nir/nir_search_helpers.h"
   1830 static const nir_search_variable replace1_0_1_0_0 = {
   1831    { nir_search_value_variable, 0 },
   1832    1, /* b */
   1833    false,
   1834    nir_type_invalid,
   1835    NULL,
   1836 };
   1837 #include "compiler/nir/nir_search_helpers.h"
   1838 static const nir_search_expression replace1_0_1_0 = {
   1839    { nir_search_value_expression, 0 },
   1840    false,
   1841    nir_op_iabs,
   1842    { &replace1_0_1_0_0.value },
   1843    NULL,
   1844 };
   1845 #include "compiler/nir/nir_search_helpers.h"
   1846 static const nir_search_expression replace1_0_1 = {
   1847    { nir_search_value_expression, 0 },
   1848    false,
   1849    nir_op_find_lsb,
   1850    { &replace1_0_1_0.value },
   1851    NULL,
   1852 };
   1853 #include "compiler/nir/nir_search_helpers.h"
   1854 static const nir_search_expression replace1_0 = {
   1855    { nir_search_value_expression, 0 },
   1856    false,
   1857    nir_op_ishl,
   1858    { &replace1_0_0.value, &replace1_0_1.value },
   1859    NULL,
   1860 };
   1861 #include "compiler/nir/nir_search_helpers.h"
   1862 static const nir_search_expression replace1 = {
   1863    { nir_search_value_expression, 0 },
   1864    false,
   1865    nir_op_ineg,
   1866    { &replace1_0.value },
   1867    NULL,
   1868 };
   1869 
   1870 #include "compiler/nir/nir_search_helpers.h"
   1871 static const nir_search_variable search30_0 = {
   1872    { nir_search_value_variable, 0 },
   1873    0, /* a */
   1874    false,
   1875    nir_type_invalid,
   1876    NULL,
   1877 };
   1878 
   1879 #include "compiler/nir/nir_search_helpers.h"
   1880 static const nir_search_constant search30_1 = {
   1881    { nir_search_value_constant, 0 },
   1882    nir_type_int, { 0x0 /* 0 */ },
   1883 };
   1884 #include "compiler/nir/nir_search_helpers.h"
   1885 static const nir_search_expression search30 = {
   1886    { nir_search_value_expression, 0 },
   1887    false,
   1888    nir_op_imul,
   1889    { &search30_0.value, &search30_1.value },
   1890    NULL,
   1891 };
   1892 
   1893 #include "compiler/nir/nir_search_helpers.h"
   1894 static const nir_search_constant replace30 = {
   1895    { nir_search_value_constant, 0 },
   1896    nir_type_int, { 0x0 /* 0 */ },
   1897 };
   1898 
   1899 #include "compiler/nir/nir_search_helpers.h"
   1900 static const nir_search_variable search34_0 = {
   1901    { nir_search_value_variable, 0 },
   1902    0, /* a */
   1903    false,
   1904    nir_type_invalid,
   1905    NULL,
   1906 };
   1907 
   1908 #include "compiler/nir/nir_search_helpers.h"
   1909 static const nir_search_constant search34_1 = {
   1910    { nir_search_value_constant, 0 },
   1911    nir_type_int, { 0x1 /* 1 */ },
   1912 };
   1913 #include "compiler/nir/nir_search_helpers.h"
   1914 static const nir_search_expression search34 = {
   1915    { nir_search_value_expression, 0 },
   1916    false,
   1917    nir_op_imul,
   1918    { &search34_0.value, &search34_1.value },
   1919    NULL,
   1920 };
   1921 
   1922 #include "compiler/nir/nir_search_helpers.h"
   1923 static const nir_search_variable replace34 = {
   1924    { nir_search_value_variable, 0 },
   1925    0, /* a */
   1926    false,
   1927    nir_type_invalid,
   1928    NULL,
   1929 };
   1930 
   1931 #include "compiler/nir/nir_search_helpers.h"
   1932 static const nir_search_variable search36_0 = {
   1933    { nir_search_value_variable, 0 },
   1934    0, /* a */
   1935    false,
   1936    nir_type_invalid,
   1937    NULL,
   1938 };
   1939 
   1940 #include "compiler/nir/nir_search_helpers.h"
   1941 static const nir_search_constant search36_1 = {
   1942    { nir_search_value_constant, 0 },
   1943    nir_type_int, { -0x1 /* -1 */ },
   1944 };
   1945 #include "compiler/nir/nir_search_helpers.h"
   1946 static const nir_search_expression search36 = {
   1947    { nir_search_value_expression, 0 },
   1948    false,
   1949    nir_op_imul,
   1950    { &search36_0.value, &search36_1.value },
   1951    NULL,
   1952 };
   1953 
   1954 #include "compiler/nir/nir_search_helpers.h"
   1955 static const nir_search_variable replace36_0 = {
   1956    { nir_search_value_variable, 0 },
   1957    0, /* a */
   1958    false,
   1959    nir_type_invalid,
   1960    NULL,
   1961 };
   1962 #include "compiler/nir/nir_search_helpers.h"
   1963 static const nir_search_expression replace36 = {
   1964    { nir_search_value_expression, 0 },
   1965    false,
   1966    nir_op_ineg,
   1967    { &replace36_0.value },
   1968    NULL,
   1969 };
   1970 
   1971 #include "compiler/nir/nir_search_helpers.h"
   1972 static const nir_search_variable search108_0_0 = {
   1973    { nir_search_value_variable, 0 },
   1974    0, /* a */
   1975    false,
   1976    nir_type_invalid,
   1977    NULL,
   1978 };
   1979 #include "compiler/nir/nir_search_helpers.h"
   1980 static const nir_search_expression search108_0 = {
   1981    { nir_search_value_expression, 0 },
   1982    false,
   1983    nir_op_b2i,
   1984    { &search108_0_0.value },
   1985    NULL,
   1986 };
   1987 
   1988 #include "compiler/nir/nir_search_helpers.h"
   1989 static const nir_search_variable search108_1_0 = {
   1990    { nir_search_value_variable, 0 },
   1991    1, /* b */
   1992    false,
   1993    nir_type_invalid,
   1994    NULL,
   1995 };
   1996 #include "compiler/nir/nir_search_helpers.h"
   1997 static const nir_search_expression search108_1 = {
   1998    { nir_search_value_expression, 0 },
   1999    false,
   2000    nir_op_b2i,
   2001    { &search108_1_0.value },
   2002    NULL,
   2003 };
   2004 #include "compiler/nir/nir_search_helpers.h"
   2005 static const nir_search_expression search108 = {
   2006    { nir_search_value_expression, 0 },
   2007    false,
   2008    nir_op_imul,
   2009    { &search108_0.value, &search108_1.value },
   2010    NULL,
   2011 };
   2012 
   2013 #include "compiler/nir/nir_search_helpers.h"
   2014 static const nir_search_variable replace108_0_0 = {
   2015    { nir_search_value_variable, 0 },
   2016    0, /* a */
   2017    false,
   2018    nir_type_invalid,
   2019    NULL,
   2020 };
   2021 
   2022 #include "compiler/nir/nir_search_helpers.h"
   2023 static const nir_search_variable replace108_0_1 = {
   2024    { nir_search_value_variable, 0 },
   2025    1, /* b */
   2026    false,
   2027    nir_type_invalid,
   2028    NULL,
   2029 };
   2030 #include "compiler/nir/nir_search_helpers.h"
   2031 static const nir_search_expression replace108_0 = {
   2032    { nir_search_value_expression, 0 },
   2033    false,
   2034    nir_op_iand,
   2035    { &replace108_0_0.value, &replace108_0_1.value },
   2036    NULL,
   2037 };
   2038 #include "compiler/nir/nir_search_helpers.h"
   2039 static const nir_search_expression replace108 = {
   2040    { nir_search_value_expression, 0 },
   2041    false,
   2042    nir_op_b2i,
   2043    { &replace108_0.value },
   2044    NULL,
   2045 };
   2046 
   2047 #include "compiler/nir/nir_search_helpers.h"
   2048 static const nir_search_variable search208_0_0 = {
   2049    { nir_search_value_variable, 0 },
   2050    0, /* a */
   2051    false,
   2052    nir_type_invalid,
   2053    NULL,
   2054 };
   2055 #include "compiler/nir/nir_search_helpers.h"
   2056 static const nir_search_expression search208_0 = {
   2057    { nir_search_value_expression, 0 },
   2058    false,
   2059    nir_op_ineg,
   2060    { &search208_0_0.value },
   2061    NULL,
   2062 };
   2063 
   2064 #include "compiler/nir/nir_search_helpers.h"
   2065 static const nir_search_variable search208_1 = {
   2066    { nir_search_value_variable, 0 },
   2067    1, /* b */
   2068    false,
   2069    nir_type_invalid,
   2070    NULL,
   2071 };
   2072 #include "compiler/nir/nir_search_helpers.h"
   2073 static const nir_search_expression search208 = {
   2074    { nir_search_value_expression, 0 },
   2075    false,
   2076    nir_op_imul,
   2077    { &search208_0.value, &search208_1.value },
   2078    NULL,
   2079 };
   2080 
   2081 #include "compiler/nir/nir_search_helpers.h"
   2082 static const nir_search_variable replace208_0_0 = {
   2083    { nir_search_value_variable, 0 },
   2084    0, /* a */
   2085    false,
   2086    nir_type_invalid,
   2087    NULL,
   2088 };
   2089 
   2090 #include "compiler/nir/nir_search_helpers.h"
   2091 static const nir_search_variable replace208_0_1 = {
   2092    { nir_search_value_variable, 0 },
   2093    1, /* b */
   2094    false,
   2095    nir_type_invalid,
   2096    NULL,
   2097 };
   2098 #include "compiler/nir/nir_search_helpers.h"
   2099 static const nir_search_expression replace208_0 = {
   2100    { nir_search_value_expression, 0 },
   2101    false,
   2102    nir_op_imul,
   2103    { &replace208_0_0.value, &replace208_0_1.value },
   2104    NULL,
   2105 };
   2106 #include "compiler/nir/nir_search_helpers.h"
   2107 static const nir_search_expression replace208 = {
   2108    { nir_search_value_expression, 0 },
   2109    false,
   2110    nir_op_ineg,
   2111    { &replace208_0.value },
   2112    NULL,
   2113 };
   2114 
   2115 #include "compiler/nir/nir_search_helpers.h"
   2116 static const nir_search_variable search210_0 = {
   2117    { nir_search_value_variable, 0 },
   2118    0, /* a */
   2119    true,
   2120    nir_type_invalid,
   2121    NULL,
   2122 };
   2123 
   2124 #include "compiler/nir/nir_search_helpers.h"
   2125 static const nir_search_variable search210_1_0 = {
   2126    { nir_search_value_variable, 0 },
   2127    1, /* b */
   2128    false,
   2129    nir_type_invalid,
   2130    NULL,
   2131 };
   2132 
   2133 #include "compiler/nir/nir_search_helpers.h"
   2134 static const nir_search_variable search210_1_1 = {
   2135    { nir_search_value_variable, 0 },
   2136    2, /* c */
   2137    true,
   2138    nir_type_invalid,
   2139    NULL,
   2140 };
   2141 #include "compiler/nir/nir_search_helpers.h"
   2142 static const nir_search_expression search210_1 = {
   2143    { nir_search_value_expression, 0 },
   2144    false,
   2145    nir_op_imul,
   2146    { &search210_1_0.value, &search210_1_1.value },
   2147    NULL,
   2148 };
   2149 #include "compiler/nir/nir_search_helpers.h"
   2150 static const nir_search_expression search210 = {
   2151    { nir_search_value_expression, 0 },
   2152    false,
   2153    nir_op_imul,
   2154    { &search210_0.value, &search210_1.value },
   2155    NULL,
   2156 };
   2157 
   2158 #include "compiler/nir/nir_search_helpers.h"
   2159 static const nir_search_variable replace210_0_0 = {
   2160    { nir_search_value_variable, 0 },
   2161    0, /* a */
   2162    false,
   2163    nir_type_invalid,
   2164    NULL,
   2165 };
   2166 
   2167 #include "compiler/nir/nir_search_helpers.h"
   2168 static const nir_search_variable replace210_0_1 = {
   2169    { nir_search_value_variable, 0 },
   2170    2, /* c */
   2171    false,
   2172    nir_type_invalid,
   2173    NULL,
   2174 };
   2175 #include "compiler/nir/nir_search_helpers.h"
   2176 static const nir_search_expression replace210_0 = {
   2177    { nir_search_value_expression, 0 },
   2178    false,
   2179    nir_op_imul,
   2180    { &replace210_0_0.value, &replace210_0_1.value },
   2181    NULL,
   2182 };
   2183 
   2184 #include "compiler/nir/nir_search_helpers.h"
   2185 static const nir_search_variable replace210_1 = {
   2186    { nir_search_value_variable, 0 },
   2187    1, /* b */
   2188    false,
   2189    nir_type_invalid,
   2190    NULL,
   2191 };
   2192 #include "compiler/nir/nir_search_helpers.h"
   2193 static const nir_search_expression replace210 = {
   2194    { nir_search_value_expression, 0 },
   2195    false,
   2196    nir_op_imul,
   2197    { &replace210_0.value, &replace210_1.value },
   2198    NULL,
   2199 };
   2200 
   2201 static const struct transform nir_opt_algebraic_imul_xforms[] = {
   2202    { &search0, &replace0.value, 0 },
   2203    { &search1, &replace1.value, 0 },
   2204    { &search30, &replace30.value, 0 },
   2205    { &search34, &replace34.value, 0 },
   2206    { &search36, &replace36.value, 0 },
   2207    { &search108, &replace108.value, 0 },
   2208    { &search208, &replace208.value, 0 },
   2209    { &search210, &replace210.value, 0 },
   2210 };
   2211 
   2212 #include "compiler/nir/nir_search_helpers.h"
   2213 static const nir_search_variable search120_0 = {
   2214    { nir_search_value_variable, 0 },
   2215    0, /* a */
   2216    false,
   2217    nir_type_invalid,
   2218    NULL,
   2219 };
   2220 
   2221 #include "compiler/nir/nir_search_helpers.h"
   2222 static const nir_search_variable search120_1 = {
   2223    { nir_search_value_variable, 0 },
   2224    0, /* a */
   2225    false,
   2226    nir_type_invalid,
   2227    NULL,
   2228 };
   2229 #include "compiler/nir/nir_search_helpers.h"
   2230 static const nir_search_expression search120 = {
   2231    { nir_search_value_expression, 0 },
   2232    false,
   2233    nir_op_uge,
   2234    { &search120_0.value, &search120_1.value },
   2235    NULL,
   2236 };
   2237 
   2238 #include "compiler/nir/nir_search_helpers.h"
   2239 static const nir_search_constant replace120 = {
   2240    { nir_search_value_constant, 32 },
   2241    nir_type_bool32, { NIR_TRUE /* True */ },
   2242 };
   2243 
   2244 #include "compiler/nir/nir_search_helpers.h"
   2245 static const nir_search_variable search260_0_0 = {
   2246    { nir_search_value_variable, 0 },
   2247    0, /* a */
   2248    false,
   2249    nir_type_invalid,
   2250    NULL,
   2251 };
   2252 
   2253 #include "compiler/nir/nir_search_helpers.h"
   2254 static const nir_search_variable search260_0_1 = {
   2255    { nir_search_value_variable, 0 },
   2256    1, /* b */
   2257    true,
   2258    nir_type_invalid,
   2259    NULL,
   2260 };
   2261 
   2262 #include "compiler/nir/nir_search_helpers.h"
   2263 static const nir_search_variable search260_0_2 = {
   2264    { nir_search_value_variable, 0 },
   2265    2, /* c */
   2266    true,
   2267    nir_type_invalid,
   2268    NULL,
   2269 };
   2270 #include "compiler/nir/nir_search_helpers.h"
   2271 static const nir_search_expression search260_0 = {
   2272    { nir_search_value_expression, 0 },
   2273    false,
   2274    nir_op_bcsel,
   2275    { &search260_0_0.value, &search260_0_1.value, &search260_0_2.value },
   2276    NULL,
   2277 };
   2278 
   2279 #include "compiler/nir/nir_search_helpers.h"
   2280 static const nir_search_variable search260_1 = {
   2281    { nir_search_value_variable, 0 },
   2282    3, /* d */
   2283    true,
   2284    nir_type_invalid,
   2285    NULL,
   2286 };
   2287 #include "compiler/nir/nir_search_helpers.h"
   2288 static const nir_search_expression search260 = {
   2289    { nir_search_value_expression, 0 },
   2290    false,
   2291    nir_op_uge,
   2292    { &search260_0.value, &search260_1.value },
   2293    NULL,
   2294 };
   2295 
   2296 #include "compiler/nir/nir_search_helpers.h"
   2297 static const nir_search_variable replace260_0 = {
   2298    { nir_search_value_variable, 0 },
   2299    0, /* a */
   2300    false,
   2301    nir_type_invalid,
   2302    NULL,
   2303 };
   2304 
   2305 #include "compiler/nir/nir_search_helpers.h"
   2306 static const nir_search_variable replace260_1_0 = {
   2307    { nir_search_value_variable, 0 },
   2308    1, /* b */
   2309    false,
   2310    nir_type_invalid,
   2311    NULL,
   2312 };
   2313 
   2314 #include "compiler/nir/nir_search_helpers.h"
   2315 static const nir_search_variable replace260_1_1 = {
   2316    { nir_search_value_variable, 0 },
   2317    3, /* d */
   2318    false,
   2319    nir_type_invalid,
   2320    NULL,
   2321 };
   2322 #include "compiler/nir/nir_search_helpers.h"
   2323 static const nir_search_expression replace260_1 = {
   2324    { nir_search_value_expression, 0 },
   2325    false,
   2326    nir_op_uge,
   2327    { &replace260_1_0.value, &replace260_1_1.value },
   2328    NULL,
   2329 };
   2330 
   2331 #include "compiler/nir/nir_search_helpers.h"
   2332 static const nir_search_variable replace260_2_0 = {
   2333    { nir_search_value_variable, 0 },
   2334    2, /* c */
   2335    false,
   2336    nir_type_invalid,
   2337    NULL,
   2338 };
   2339 
   2340 #include "compiler/nir/nir_search_helpers.h"
   2341 static const nir_search_variable replace260_2_1 = {
   2342    { nir_search_value_variable, 0 },
   2343    3, /* d */
   2344    false,
   2345    nir_type_invalid,
   2346    NULL,
   2347 };
   2348 #include "compiler/nir/nir_search_helpers.h"
   2349 static const nir_search_expression replace260_2 = {
   2350    { nir_search_value_expression, 0 },
   2351    false,
   2352    nir_op_uge,
   2353    { &replace260_2_0.value, &replace260_2_1.value },
   2354    NULL,
   2355 };
   2356 #include "compiler/nir/nir_search_helpers.h"
   2357 static const nir_search_expression replace260 = {
   2358    { nir_search_value_expression, 0 },
   2359    false,
   2360    nir_op_bcsel,
   2361    { &replace260_0.value, &replace260_1.value, &replace260_2.value },
   2362    NULL,
   2363 };
   2364 
   2365 #include "compiler/nir/nir_search_helpers.h"
   2366 static const nir_search_variable search261_0 = {
   2367    { nir_search_value_variable, 0 },
   2368    0, /* d */
   2369    true,
   2370    nir_type_invalid,
   2371    NULL,
   2372 };
   2373 
   2374 #include "compiler/nir/nir_search_helpers.h"
   2375 static const nir_search_variable search261_1_0 = {
   2376    { nir_search_value_variable, 0 },
   2377    1, /* a */
   2378    false,
   2379    nir_type_invalid,
   2380    NULL,
   2381 };
   2382 
   2383 #include "compiler/nir/nir_search_helpers.h"
   2384 static const nir_search_variable search261_1_1 = {
   2385    { nir_search_value_variable, 0 },
   2386    2, /* b */
   2387    true,
   2388    nir_type_invalid,
   2389    NULL,
   2390 };
   2391 
   2392 #include "compiler/nir/nir_search_helpers.h"
   2393 static const nir_search_variable search261_1_2 = {
   2394    { nir_search_value_variable, 0 },
   2395    3, /* c */
   2396    true,
   2397    nir_type_invalid,
   2398    NULL,
   2399 };
   2400 #include "compiler/nir/nir_search_helpers.h"
   2401 static const nir_search_expression search261_1 = {
   2402    { nir_search_value_expression, 0 },
   2403    false,
   2404    nir_op_bcsel,
   2405    { &search261_1_0.value, &search261_1_1.value, &search261_1_2.value },
   2406    NULL,
   2407 };
   2408 #include "compiler/nir/nir_search_helpers.h"
   2409 static const nir_search_expression search261 = {
   2410    { nir_search_value_expression, 0 },
   2411    false,
   2412    nir_op_uge,
   2413    { &search261_0.value, &search261_1.value },
   2414    NULL,
   2415 };
   2416 
   2417 #include "compiler/nir/nir_search_helpers.h"
   2418 static const nir_search_variable replace261_0 = {
   2419    { nir_search_value_variable, 0 },
   2420    1, /* a */
   2421    false,
   2422    nir_type_invalid,
   2423    NULL,
   2424 };
   2425 
   2426 #include "compiler/nir/nir_search_helpers.h"
   2427 static const nir_search_variable replace261_1_0 = {
   2428    { nir_search_value_variable, 0 },
   2429    0, /* d */
   2430    false,
   2431    nir_type_invalid,
   2432    NULL,
   2433 };
   2434 
   2435 #include "compiler/nir/nir_search_helpers.h"
   2436 static const nir_search_variable replace261_1_1 = {
   2437    { nir_search_value_variable, 0 },
   2438    2, /* b */
   2439    false,
   2440    nir_type_invalid,
   2441    NULL,
   2442 };
   2443 #include "compiler/nir/nir_search_helpers.h"
   2444 static const nir_search_expression replace261_1 = {
   2445    { nir_search_value_expression, 0 },
   2446    false,
   2447    nir_op_uge,
   2448    { &replace261_1_0.value, &replace261_1_1.value },
   2449    NULL,
   2450 };
   2451 
   2452 #include "compiler/nir/nir_search_helpers.h"
   2453 static const nir_search_variable replace261_2_0 = {
   2454    { nir_search_value_variable, 0 },
   2455    0, /* d */
   2456    false,
   2457    nir_type_invalid,
   2458    NULL,
   2459 };
   2460 
   2461 #include "compiler/nir/nir_search_helpers.h"
   2462 static const nir_search_variable replace261_2_1 = {
   2463    { nir_search_value_variable, 0 },
   2464    3, /* c */
   2465    false,
   2466    nir_type_invalid,
   2467    NULL,
   2468 };
   2469 #include "compiler/nir/nir_search_helpers.h"
   2470 static const nir_search_expression replace261_2 = {
   2471    { nir_search_value_expression, 0 },
   2472    false,
   2473    nir_op_uge,
   2474    { &replace261_2_0.value, &replace261_2_1.value },
   2475    NULL,
   2476 };
   2477 #include "compiler/nir/nir_search_helpers.h"
   2478 static const nir_search_expression replace261 = {
   2479    { nir_search_value_expression, 0 },
   2480    false,
   2481    nir_op_bcsel,
   2482    { &replace261_0.value, &replace261_1.value, &replace261_2.value },
   2483    NULL,
   2484 };
   2485 
   2486 static const struct transform nir_opt_algebraic_uge_xforms[] = {
   2487    { &search120, &replace120.value, 0 },
   2488    { &search260, &replace260.value, 0 },
   2489    { &search261, &replace261.value, 0 },
   2490 };
   2491 
   2492 #include "compiler/nir/nir_search_helpers.h"
   2493 static const nir_search_variable search11_0_0 = {
   2494    { nir_search_value_variable, 0 },
   2495    0, /* a */
   2496    false,
   2497    nir_type_invalid,
   2498    NULL,
   2499 };
   2500 #include "compiler/nir/nir_search_helpers.h"
   2501 static const nir_search_expression search11_0 = {
   2502    { nir_search_value_expression, 0 },
   2503    false,
   2504    nir_op_ineg,
   2505    { &search11_0_0.value },
   2506    NULL,
   2507 };
   2508 #include "compiler/nir/nir_search_helpers.h"
   2509 static const nir_search_expression search11 = {
   2510    { nir_search_value_expression, 0 },
   2511    false,
   2512    nir_op_ineg,
   2513    { &search11_0.value },
   2514    NULL,
   2515 };
   2516 
   2517 #include "compiler/nir/nir_search_helpers.h"
   2518 static const nir_search_variable replace11 = {
   2519    { nir_search_value_variable, 0 },
   2520    0, /* a */
   2521    false,
   2522    nir_type_invalid,
   2523    NULL,
   2524 };
   2525 
   2526 #include "compiler/nir/nir_search_helpers.h"
   2527 static const nir_search_variable search112_0_0 = {
   2528    { nir_search_value_variable, 0 },
   2529    0, /* a */
   2530    false,
   2531    nir_type_invalid,
   2532    NULL,
   2533 };
   2534 #include "compiler/nir/nir_search_helpers.h"
   2535 static const nir_search_expression search112_0 = {
   2536    { nir_search_value_expression, 0 },
   2537    false,
   2538    nir_op_b2i,
   2539    { &search112_0_0.value },
   2540    NULL,
   2541 };
   2542 #include "compiler/nir/nir_search_helpers.h"
   2543 static const nir_search_expression search112 = {
   2544    { nir_search_value_expression, 0 },
   2545    false,
   2546    nir_op_ineg,
   2547    { &search112_0.value },
   2548    NULL,
   2549 };
   2550 
   2551 #include "compiler/nir/nir_search_helpers.h"
   2552 static const nir_search_variable replace112 = {
   2553    { nir_search_value_variable, 0 },
   2554    0, /* a */
   2555    false,
   2556    nir_type_invalid,
   2557    NULL,
   2558 };
   2559 
   2560 #include "compiler/nir/nir_search_helpers.h"
   2561 static const nir_search_variable search202_0 = {
   2562    { nir_search_value_variable, 0 },
   2563    0, /* a */
   2564    false,
   2565    nir_type_invalid,
   2566    NULL,
   2567 };
   2568 #include "compiler/nir/nir_search_helpers.h"
   2569 static const nir_search_expression search202 = {
   2570    { nir_search_value_expression, 0 },
   2571    false,
   2572    nir_op_ineg,
   2573    { &search202_0.value },
   2574    NULL,
   2575 };
   2576 
   2577 #include "compiler/nir/nir_search_helpers.h"
   2578 static const nir_search_constant replace202_0 = {
   2579    { nir_search_value_constant, 0 },
   2580    nir_type_int, { 0x0 /* 0 */ },
   2581 };
   2582 
   2583 #include "compiler/nir/nir_search_helpers.h"
   2584 static const nir_search_variable replace202_1 = {
   2585    { nir_search_value_variable, 0 },
   2586    0, /* a */
   2587    false,
   2588    nir_type_invalid,
   2589    NULL,
   2590 };
   2591 #include "compiler/nir/nir_search_helpers.h"
   2592 static const nir_search_expression replace202 = {
   2593    { nir_search_value_expression, 0 },
   2594    false,
   2595    nir_op_isub,
   2596    { &replace202_0.value, &replace202_1.value },
   2597    NULL,
   2598 };
   2599 
   2600 static const struct transform nir_opt_algebraic_ineg_xforms[] = {
   2601    { &search11, &replace11.value, 0 },
   2602    { &search112, &replace112.value, 0 },
   2603    { &search202, &replace202.value, 20 },
   2604 };
   2605 
   2606 #include "compiler/nir/nir_search_helpers.h"
   2607 static const nir_search_variable search29_0 = {
   2608    { nir_search_value_variable, 0 },
   2609    0, /* a */
   2610    false,
   2611    nir_type_invalid,
   2612    NULL,
   2613 };
   2614 
   2615 #include "compiler/nir/nir_search_helpers.h"
   2616 static const nir_search_constant search29_1 = {
   2617    { nir_search_value_constant, 0 },
   2618    nir_type_float, { 0x0 /* 0.0 */ },
   2619 };
   2620 #include "compiler/nir/nir_search_helpers.h"
   2621 static const nir_search_expression search29 = {
   2622    { nir_search_value_expression, 0 },
   2623    true,
   2624    nir_op_fmul,
   2625    { &search29_0.value, &search29_1.value },
   2626    NULL,
   2627 };
   2628 
   2629 #include "compiler/nir/nir_search_helpers.h"
   2630 static const nir_search_constant replace29 = {
   2631    { nir_search_value_constant, 0 },
   2632    nir_type_float, { 0x0 /* 0.0 */ },
   2633 };
   2634 
   2635 #include "compiler/nir/nir_search_helpers.h"
   2636 static const nir_search_variable search33_0 = {
   2637    { nir_search_value_variable, 0 },
   2638    0, /* a */
   2639    false,
   2640    nir_type_invalid,
   2641    NULL,
   2642 };
   2643 
   2644 #include "compiler/nir/nir_search_helpers.h"
   2645 static const nir_search_constant search33_1 = {
   2646    { nir_search_value_constant, 0 },
   2647    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   2648 };
   2649 #include "compiler/nir/nir_search_helpers.h"
   2650 static const nir_search_expression search33 = {
   2651    { nir_search_value_expression, 0 },
   2652    false,
   2653    nir_op_fmul,
   2654    { &search33_0.value, &search33_1.value },
   2655    NULL,
   2656 };
   2657 
   2658 #include "compiler/nir/nir_search_helpers.h"
   2659 static const nir_search_variable replace33 = {
   2660    { nir_search_value_variable, 0 },
   2661    0, /* a */
   2662    false,
   2663    nir_type_invalid,
   2664    NULL,
   2665 };
   2666 
   2667 #include "compiler/nir/nir_search_helpers.h"
   2668 static const nir_search_variable search35_0 = {
   2669    { nir_search_value_variable, 0 },
   2670    0, /* a */
   2671    false,
   2672    nir_type_invalid,
   2673    NULL,
   2674 };
   2675 
   2676 #include "compiler/nir/nir_search_helpers.h"
   2677 static const nir_search_constant search35_1 = {
   2678    { nir_search_value_constant, 0 },
   2679    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   2680 };
   2681 #include "compiler/nir/nir_search_helpers.h"
   2682 static const nir_search_expression search35 = {
   2683    { nir_search_value_expression, 0 },
   2684    false,
   2685    nir_op_fmul,
   2686    { &search35_0.value, &search35_1.value },
   2687    NULL,
   2688 };
   2689 
   2690 #include "compiler/nir/nir_search_helpers.h"
   2691 static const nir_search_variable replace35_0 = {
   2692    { nir_search_value_variable, 0 },
   2693    0, /* a */
   2694    false,
   2695    nir_type_invalid,
   2696    NULL,
   2697 };
   2698 #include "compiler/nir/nir_search_helpers.h"
   2699 static const nir_search_expression replace35 = {
   2700    { nir_search_value_expression, 0 },
   2701    false,
   2702    nir_op_fneg,
   2703    { &replace35_0.value },
   2704    NULL,
   2705 };
   2706 
   2707 #include "compiler/nir/nir_search_helpers.h"
   2708 static const nir_search_variable search109_0_0 = {
   2709    { nir_search_value_variable, 0 },
   2710    0, /* a */
   2711    false,
   2712    nir_type_invalid,
   2713    NULL,
   2714 };
   2715 #include "compiler/nir/nir_search_helpers.h"
   2716 static const nir_search_expression search109_0 = {
   2717    { nir_search_value_expression, 0 },
   2718    false,
   2719    nir_op_b2f,
   2720    { &search109_0_0.value },
   2721    NULL,
   2722 };
   2723 
   2724 #include "compiler/nir/nir_search_helpers.h"
   2725 static const nir_search_variable search109_1_0 = {
   2726    { nir_search_value_variable, 0 },
   2727    1, /* b */
   2728    false,
   2729    nir_type_invalid,
   2730    NULL,
   2731 };
   2732 #include "compiler/nir/nir_search_helpers.h"
   2733 static const nir_search_expression search109_1 = {
   2734    { nir_search_value_expression, 0 },
   2735    false,
   2736    nir_op_b2f,
   2737    { &search109_1_0.value },
   2738    NULL,
   2739 };
   2740 #include "compiler/nir/nir_search_helpers.h"
   2741 static const nir_search_expression search109 = {
   2742    { nir_search_value_expression, 0 },
   2743    false,
   2744    nir_op_fmul,
   2745    { &search109_0.value, &search109_1.value },
   2746    NULL,
   2747 };
   2748 
   2749 #include "compiler/nir/nir_search_helpers.h"
   2750 static const nir_search_variable replace109_0_0 = {
   2751    { nir_search_value_variable, 0 },
   2752    0, /* a */
   2753    false,
   2754    nir_type_invalid,
   2755    NULL,
   2756 };
   2757 
   2758 #include "compiler/nir/nir_search_helpers.h"
   2759 static const nir_search_variable replace109_0_1 = {
   2760    { nir_search_value_variable, 0 },
   2761    1, /* b */
   2762    false,
   2763    nir_type_invalid,
   2764    NULL,
   2765 };
   2766 #include "compiler/nir/nir_search_helpers.h"
   2767 static const nir_search_expression replace109_0 = {
   2768    { nir_search_value_expression, 0 },
   2769    false,
   2770    nir_op_iand,
   2771    { &replace109_0_0.value, &replace109_0_1.value },
   2772    NULL,
   2773 };
   2774 #include "compiler/nir/nir_search_helpers.h"
   2775 static const nir_search_expression replace109 = {
   2776    { nir_search_value_expression, 0 },
   2777    false,
   2778    nir_op_b2f,
   2779    { &replace109_0.value },
   2780    NULL,
   2781 };
   2782 
   2783 #include "compiler/nir/nir_search_helpers.h"
   2784 static const nir_search_variable search160_0_0 = {
   2785    { nir_search_value_variable, 0 },
   2786    0, /* a */
   2787    false,
   2788    nir_type_invalid,
   2789    NULL,
   2790 };
   2791 #include "compiler/nir/nir_search_helpers.h"
   2792 static const nir_search_expression search160_0 = {
   2793    { nir_search_value_expression, 0 },
   2794    false,
   2795    nir_op_fexp2,
   2796    { &search160_0_0.value },
   2797    NULL,
   2798 };
   2799 
   2800 #include "compiler/nir/nir_search_helpers.h"
   2801 static const nir_search_variable search160_1_0 = {
   2802    { nir_search_value_variable, 0 },
   2803    1, /* b */
   2804    false,
   2805    nir_type_invalid,
   2806    NULL,
   2807 };
   2808 #include "compiler/nir/nir_search_helpers.h"
   2809 static const nir_search_expression search160_1 = {
   2810    { nir_search_value_expression, 0 },
   2811    false,
   2812    nir_op_fexp2,
   2813    { &search160_1_0.value },
   2814    NULL,
   2815 };
   2816 #include "compiler/nir/nir_search_helpers.h"
   2817 static const nir_search_expression search160 = {
   2818    { nir_search_value_expression, 0 },
   2819    true,
   2820    nir_op_fmul,
   2821    { &search160_0.value, &search160_1.value },
   2822    NULL,
   2823 };
   2824 
   2825 #include "compiler/nir/nir_search_helpers.h"
   2826 static const nir_search_variable replace160_0_0 = {
   2827    { nir_search_value_variable, 0 },
   2828    0, /* a */
   2829    false,
   2830    nir_type_invalid,
   2831    NULL,
   2832 };
   2833 
   2834 #include "compiler/nir/nir_search_helpers.h"
   2835 static const nir_search_variable replace160_0_1 = {
   2836    { nir_search_value_variable, 0 },
   2837    1, /* b */
   2838    false,
   2839    nir_type_invalid,
   2840    NULL,
   2841 };
   2842 #include "compiler/nir/nir_search_helpers.h"
   2843 static const nir_search_expression replace160_0 = {
   2844    { nir_search_value_expression, 0 },
   2845    false,
   2846    nir_op_fadd,
   2847    { &replace160_0_0.value, &replace160_0_1.value },
   2848    NULL,
   2849 };
   2850 #include "compiler/nir/nir_search_helpers.h"
   2851 static const nir_search_expression replace160 = {
   2852    { nir_search_value_expression, 0 },
   2853    false,
   2854    nir_op_fexp2,
   2855    { &replace160_0.value },
   2856    NULL,
   2857 };
   2858 
   2859 #include "compiler/nir/nir_search_helpers.h"
   2860 static const nir_search_variable search207_0_0 = {
   2861    { nir_search_value_variable, 0 },
   2862    0, /* a */
   2863    false,
   2864    nir_type_invalid,
   2865    NULL,
   2866 };
   2867 #include "compiler/nir/nir_search_helpers.h"
   2868 static const nir_search_expression search207_0 = {
   2869    { nir_search_value_expression, 0 },
   2870    false,
   2871    nir_op_fneg,
   2872    { &search207_0_0.value },
   2873    NULL,
   2874 };
   2875 
   2876 #include "compiler/nir/nir_search_helpers.h"
   2877 static const nir_search_variable search207_1 = {
   2878    { nir_search_value_variable, 0 },
   2879    1, /* b */
   2880    false,
   2881    nir_type_invalid,
   2882    NULL,
   2883 };
   2884 #include "compiler/nir/nir_search_helpers.h"
   2885 static const nir_search_expression search207 = {
   2886    { nir_search_value_expression, 0 },
   2887    false,
   2888    nir_op_fmul,
   2889    { &search207_0.value, &search207_1.value },
   2890    NULL,
   2891 };
   2892 
   2893 #include "compiler/nir/nir_search_helpers.h"
   2894 static const nir_search_variable replace207_0_0 = {
   2895    { nir_search_value_variable, 0 },
   2896    0, /* a */
   2897    false,
   2898    nir_type_invalid,
   2899    NULL,
   2900 };
   2901 
   2902 #include "compiler/nir/nir_search_helpers.h"
   2903 static const nir_search_variable replace207_0_1 = {
   2904    { nir_search_value_variable, 0 },
   2905    1, /* b */
   2906    false,
   2907    nir_type_invalid,
   2908    NULL,
   2909 };
   2910 #include "compiler/nir/nir_search_helpers.h"
   2911 static const nir_search_expression replace207_0 = {
   2912    { nir_search_value_expression, 0 },
   2913    false,
   2914    nir_op_fmul,
   2915    { &replace207_0_0.value, &replace207_0_1.value },
   2916    NULL,
   2917 };
   2918 #include "compiler/nir/nir_search_helpers.h"
   2919 static const nir_search_expression replace207 = {
   2920    { nir_search_value_expression, 0 },
   2921    false,
   2922    nir_op_fneg,
   2923    { &replace207_0.value },
   2924    NULL,
   2925 };
   2926 
   2927 #include "compiler/nir/nir_search_helpers.h"
   2928 static const nir_search_variable search209_0 = {
   2929    { nir_search_value_variable, 0 },
   2930    0, /* a */
   2931    true,
   2932    nir_type_invalid,
   2933    NULL,
   2934 };
   2935 
   2936 #include "compiler/nir/nir_search_helpers.h"
   2937 static const nir_search_variable search209_1_0 = {
   2938    { nir_search_value_variable, 0 },
   2939    1, /* b */
   2940    false,
   2941    nir_type_invalid,
   2942    NULL,
   2943 };
   2944 
   2945 #include "compiler/nir/nir_search_helpers.h"
   2946 static const nir_search_variable search209_1_1 = {
   2947    { nir_search_value_variable, 0 },
   2948    2, /* c */
   2949    true,
   2950    nir_type_invalid,
   2951    NULL,
   2952 };
   2953 #include "compiler/nir/nir_search_helpers.h"
   2954 static const nir_search_expression search209_1 = {
   2955    { nir_search_value_expression, 0 },
   2956    false,
   2957    nir_op_fmul,
   2958    { &search209_1_0.value, &search209_1_1.value },
   2959    NULL,
   2960 };
   2961 #include "compiler/nir/nir_search_helpers.h"
   2962 static const nir_search_expression search209 = {
   2963    { nir_search_value_expression, 0 },
   2964    true,
   2965    nir_op_fmul,
   2966    { &search209_0.value, &search209_1.value },
   2967    NULL,
   2968 };
   2969 
   2970 #include "compiler/nir/nir_search_helpers.h"
   2971 static const nir_search_variable replace209_0_0 = {
   2972    { nir_search_value_variable, 0 },
   2973    0, /* a */
   2974    false,
   2975    nir_type_invalid,
   2976    NULL,
   2977 };
   2978 
   2979 #include "compiler/nir/nir_search_helpers.h"
   2980 static const nir_search_variable replace209_0_1 = {
   2981    { nir_search_value_variable, 0 },
   2982    2, /* c */
   2983    false,
   2984    nir_type_invalid,
   2985    NULL,
   2986 };
   2987 #include "compiler/nir/nir_search_helpers.h"
   2988 static const nir_search_expression replace209_0 = {
   2989    { nir_search_value_expression, 0 },
   2990    false,
   2991    nir_op_fmul,
   2992    { &replace209_0_0.value, &replace209_0_1.value },
   2993    NULL,
   2994 };
   2995 
   2996 #include "compiler/nir/nir_search_helpers.h"
   2997 static const nir_search_variable replace209_1 = {
   2998    { nir_search_value_variable, 0 },
   2999    1, /* b */
   3000    false,
   3001    nir_type_invalid,
   3002    NULL,
   3003 };
   3004 #include "compiler/nir/nir_search_helpers.h"
   3005 static const nir_search_expression replace209 = {
   3006    { nir_search_value_expression, 0 },
   3007    false,
   3008    nir_op_fmul,
   3009    { &replace209_0.value, &replace209_1.value },
   3010    NULL,
   3011 };
   3012 
   3013 static const struct transform nir_opt_algebraic_fmul_xforms[] = {
   3014    { &search29, &replace29.value, 0 },
   3015    { &search33, &replace33.value, 0 },
   3016    { &search35, &replace35.value, 0 },
   3017    { &search109, &replace109.value, 0 },
   3018    { &search160, &replace160.value, 0 },
   3019    { &search207, &replace207.value, 0 },
   3020    { &search209, &replace209.value, 0 },
   3021 };
   3022 
   3023 #include "compiler/nir/nir_search_helpers.h"
   3024 static const nir_search_variable search220_0 = {
   3025    { nir_search_value_variable, 0 },
   3026    0, /* value */
   3027    false,
   3028    nir_type_invalid,
   3029    NULL,
   3030 };
   3031 
   3032 #include "compiler/nir/nir_search_helpers.h"
   3033 static const nir_search_variable search220_1 = {
   3034    { nir_search_value_variable, 0 },
   3035    1, /* offset */
   3036    false,
   3037    nir_type_invalid,
   3038    NULL,
   3039 };
   3040 
   3041 #include "compiler/nir/nir_search_helpers.h"
   3042 static const nir_search_variable search220_2 = {
   3043    { nir_search_value_variable, 0 },
   3044    2, /* bits */
   3045    false,
   3046    nir_type_invalid,
   3047    NULL,
   3048 };
   3049 #include "compiler/nir/nir_search_helpers.h"
   3050 static const nir_search_expression search220 = {
   3051    { nir_search_value_expression, 0 },
   3052    false,
   3053    nir_op_ubitfield_extract,
   3054    { &search220_0.value, &search220_1.value, &search220_2.value },
   3055    NULL,
   3056 };
   3057 
   3058 #include "compiler/nir/nir_search_helpers.h"
   3059 static const nir_search_constant replace220_0_0 = {
   3060    { nir_search_value_constant, 0 },
   3061    nir_type_int, { 0x1f /* 31 */ },
   3062 };
   3063 
   3064 #include "compiler/nir/nir_search_helpers.h"
   3065 static const nir_search_variable replace220_0_1 = {
   3066    { nir_search_value_variable, 0 },
   3067    2, /* bits */
   3068    false,
   3069    nir_type_invalid,
   3070    NULL,
   3071 };
   3072 #include "compiler/nir/nir_search_helpers.h"
   3073 static const nir_search_expression replace220_0 = {
   3074    { nir_search_value_expression, 0 },
   3075    false,
   3076    nir_op_ult,
   3077    { &replace220_0_0.value, &replace220_0_1.value },
   3078    NULL,
   3079 };
   3080 
   3081 #include "compiler/nir/nir_search_helpers.h"
   3082 static const nir_search_variable replace220_1 = {
   3083    { nir_search_value_variable, 0 },
   3084    0, /* value */
   3085    false,
   3086    nir_type_invalid,
   3087    NULL,
   3088 };
   3089 
   3090 #include "compiler/nir/nir_search_helpers.h"
   3091 static const nir_search_variable replace220_2_0 = {
   3092    { nir_search_value_variable, 0 },
   3093    0, /* value */
   3094    false,
   3095    nir_type_invalid,
   3096    NULL,
   3097 };
   3098 
   3099 #include "compiler/nir/nir_search_helpers.h"
   3100 static const nir_search_variable replace220_2_1 = {
   3101    { nir_search_value_variable, 0 },
   3102    1, /* offset */
   3103    false,
   3104    nir_type_invalid,
   3105    NULL,
   3106 };
   3107 
   3108 #include "compiler/nir/nir_search_helpers.h"
   3109 static const nir_search_variable replace220_2_2 = {
   3110    { nir_search_value_variable, 0 },
   3111    2, /* bits */
   3112    false,
   3113    nir_type_invalid,
   3114    NULL,
   3115 };
   3116 #include "compiler/nir/nir_search_helpers.h"
   3117 static const nir_search_expression replace220_2 = {
   3118    { nir_search_value_expression, 0 },
   3119    false,
   3120    nir_op_ubfe,
   3121    { &replace220_2_0.value, &replace220_2_1.value, &replace220_2_2.value },
   3122    NULL,
   3123 };
   3124 #include "compiler/nir/nir_search_helpers.h"
   3125 static const nir_search_expression replace220 = {
   3126    { nir_search_value_expression, 0 },
   3127    false,
   3128    nir_op_bcsel,
   3129    { &replace220_0.value, &replace220_1.value, &replace220_2.value },
   3130    NULL,
   3131 };
   3132 
   3133 static const struct transform nir_opt_algebraic_ubitfield_extract_xforms[] = {
   3134    { &search220, &replace220.value, 26 },
   3135 };
   3136 
   3137 #include "compiler/nir/nir_search_helpers.h"
   3138 static const nir_search_constant search37_0 = {
   3139    { nir_search_value_constant, 0 },
   3140    nir_type_float, { 0x0 /* 0.0 */ },
   3141 };
   3142 
   3143 #include "compiler/nir/nir_search_helpers.h"
   3144 static const nir_search_variable search37_1 = {
   3145    { nir_search_value_variable, 0 },
   3146    0, /* a */
   3147    false,
   3148    nir_type_invalid,
   3149    NULL,
   3150 };
   3151 
   3152 #include "compiler/nir/nir_search_helpers.h"
   3153 static const nir_search_variable search37_2 = {
   3154    { nir_search_value_variable, 0 },
   3155    1, /* b */
   3156    false,
   3157    nir_type_invalid,
   3158    NULL,
   3159 };
   3160 #include "compiler/nir/nir_search_helpers.h"
   3161 static const nir_search_expression search37 = {
   3162    { nir_search_value_expression, 0 },
   3163    true,
   3164    nir_op_ffma,
   3165    { &search37_0.value, &search37_1.value, &search37_2.value },
   3166    NULL,
   3167 };
   3168 
   3169 #include "compiler/nir/nir_search_helpers.h"
   3170 static const nir_search_variable replace37 = {
   3171    { nir_search_value_variable, 0 },
   3172    1, /* b */
   3173    false,
   3174    nir_type_invalid,
   3175    NULL,
   3176 };
   3177 
   3178 #include "compiler/nir/nir_search_helpers.h"
   3179 static const nir_search_variable search38_0 = {
   3180    { nir_search_value_variable, 0 },
   3181    0, /* a */
   3182    false,
   3183    nir_type_invalid,
   3184    NULL,
   3185 };
   3186 
   3187 #include "compiler/nir/nir_search_helpers.h"
   3188 static const nir_search_constant search38_1 = {
   3189    { nir_search_value_constant, 0 },
   3190    nir_type_float, { 0x0 /* 0.0 */ },
   3191 };
   3192 
   3193 #include "compiler/nir/nir_search_helpers.h"
   3194 static const nir_search_variable search38_2 = {
   3195    { nir_search_value_variable, 0 },
   3196    1, /* b */
   3197    false,
   3198    nir_type_invalid,
   3199    NULL,
   3200 };
   3201 #include "compiler/nir/nir_search_helpers.h"
   3202 static const nir_search_expression search38 = {
   3203    { nir_search_value_expression, 0 },
   3204    true,
   3205    nir_op_ffma,
   3206    { &search38_0.value, &search38_1.value, &search38_2.value },
   3207    NULL,
   3208 };
   3209 
   3210 #include "compiler/nir/nir_search_helpers.h"
   3211 static const nir_search_variable replace38 = {
   3212    { nir_search_value_variable, 0 },
   3213    1, /* b */
   3214    false,
   3215    nir_type_invalid,
   3216    NULL,
   3217 };
   3218 
   3219 #include "compiler/nir/nir_search_helpers.h"
   3220 static const nir_search_variable search39_0 = {
   3221    { nir_search_value_variable, 0 },
   3222    0, /* a */
   3223    false,
   3224    nir_type_invalid,
   3225    NULL,
   3226 };
   3227 
   3228 #include "compiler/nir/nir_search_helpers.h"
   3229 static const nir_search_variable search39_1 = {
   3230    { nir_search_value_variable, 0 },
   3231    1, /* b */
   3232    false,
   3233    nir_type_invalid,
   3234    NULL,
   3235 };
   3236 
   3237 #include "compiler/nir/nir_search_helpers.h"
   3238 static const nir_search_constant search39_2 = {
   3239    { nir_search_value_constant, 0 },
   3240    nir_type_float, { 0x0 /* 0.0 */ },
   3241 };
   3242 #include "compiler/nir/nir_search_helpers.h"
   3243 static const nir_search_expression search39 = {
   3244    { nir_search_value_expression, 0 },
   3245    true,
   3246    nir_op_ffma,
   3247    { &search39_0.value, &search39_1.value, &search39_2.value },
   3248    NULL,
   3249 };
   3250 
   3251 #include "compiler/nir/nir_search_helpers.h"
   3252 static const nir_search_variable replace39_0 = {
   3253    { nir_search_value_variable, 0 },
   3254    0, /* a */
   3255    false,
   3256    nir_type_invalid,
   3257    NULL,
   3258 };
   3259 
   3260 #include "compiler/nir/nir_search_helpers.h"
   3261 static const nir_search_variable replace39_1 = {
   3262    { nir_search_value_variable, 0 },
   3263    1, /* b */
   3264    false,
   3265    nir_type_invalid,
   3266    NULL,
   3267 };
   3268 #include "compiler/nir/nir_search_helpers.h"
   3269 static const nir_search_expression replace39 = {
   3270    { nir_search_value_expression, 0 },
   3271    false,
   3272    nir_op_fmul,
   3273    { &replace39_0.value, &replace39_1.value },
   3274    NULL,
   3275 };
   3276 
   3277 #include "compiler/nir/nir_search_helpers.h"
   3278 static const nir_search_variable search40_0 = {
   3279    { nir_search_value_variable, 0 },
   3280    0, /* a */
   3281    false,
   3282    nir_type_invalid,
   3283    NULL,
   3284 };
   3285 
   3286 #include "compiler/nir/nir_search_helpers.h"
   3287 static const nir_search_constant search40_1 = {
   3288    { nir_search_value_constant, 0 },
   3289    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   3290 };
   3291 
   3292 #include "compiler/nir/nir_search_helpers.h"
   3293 static const nir_search_variable search40_2 = {
   3294    { nir_search_value_variable, 0 },
   3295    1, /* b */
   3296    false,
   3297    nir_type_invalid,
   3298    NULL,
   3299 };
   3300 #include "compiler/nir/nir_search_helpers.h"
   3301 static const nir_search_expression search40 = {
   3302    { nir_search_value_expression, 0 },
   3303    false,
   3304    nir_op_ffma,
   3305    { &search40_0.value, &search40_1.value, &search40_2.value },
   3306    NULL,
   3307 };
   3308 
   3309 #include "compiler/nir/nir_search_helpers.h"
   3310 static const nir_search_variable replace40_0 = {
   3311    { nir_search_value_variable, 0 },
   3312    0, /* a */
   3313    false,
   3314    nir_type_invalid,
   3315    NULL,
   3316 };
   3317 
   3318 #include "compiler/nir/nir_search_helpers.h"
   3319 static const nir_search_variable replace40_1 = {
   3320    { nir_search_value_variable, 0 },
   3321    1, /* b */
   3322    false,
   3323    nir_type_invalid,
   3324    NULL,
   3325 };
   3326 #include "compiler/nir/nir_search_helpers.h"
   3327 static const nir_search_expression replace40 = {
   3328    { nir_search_value_expression, 0 },
   3329    false,
   3330    nir_op_fadd,
   3331    { &replace40_0.value, &replace40_1.value },
   3332    NULL,
   3333 };
   3334 
   3335 #include "compiler/nir/nir_search_helpers.h"
   3336 static const nir_search_constant search41_0 = {
   3337    { nir_search_value_constant, 0 },
   3338    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   3339 };
   3340 
   3341 #include "compiler/nir/nir_search_helpers.h"
   3342 static const nir_search_variable search41_1 = {
   3343    { nir_search_value_variable, 0 },
   3344    0, /* a */
   3345    false,
   3346    nir_type_invalid,
   3347    NULL,
   3348 };
   3349 
   3350 #include "compiler/nir/nir_search_helpers.h"
   3351 static const nir_search_variable search41_2 = {
   3352    { nir_search_value_variable, 0 },
   3353    1, /* b */
   3354    false,
   3355    nir_type_invalid,
   3356    NULL,
   3357 };
   3358 #include "compiler/nir/nir_search_helpers.h"
   3359 static const nir_search_expression search41 = {
   3360    { nir_search_value_expression, 0 },
   3361    false,
   3362    nir_op_ffma,
   3363    { &search41_0.value, &search41_1.value, &search41_2.value },
   3364    NULL,
   3365 };
   3366 
   3367 #include "compiler/nir/nir_search_helpers.h"
   3368 static const nir_search_variable replace41_0 = {
   3369    { nir_search_value_variable, 0 },
   3370    0, /* a */
   3371    false,
   3372    nir_type_invalid,
   3373    NULL,
   3374 };
   3375 
   3376 #include "compiler/nir/nir_search_helpers.h"
   3377 static const nir_search_variable replace41_1 = {
   3378    { nir_search_value_variable, 0 },
   3379    1, /* b */
   3380    false,
   3381    nir_type_invalid,
   3382    NULL,
   3383 };
   3384 #include "compiler/nir/nir_search_helpers.h"
   3385 static const nir_search_expression replace41 = {
   3386    { nir_search_value_expression, 0 },
   3387    false,
   3388    nir_op_fadd,
   3389    { &replace41_0.value, &replace41_1.value },
   3390    NULL,
   3391 };
   3392 
   3393 #include "compiler/nir/nir_search_helpers.h"
   3394 static const nir_search_variable search57_0 = {
   3395    { nir_search_value_variable, 0 },
   3396    0, /* a */
   3397    false,
   3398    nir_type_invalid,
   3399    NULL,
   3400 };
   3401 
   3402 #include "compiler/nir/nir_search_helpers.h"
   3403 static const nir_search_variable search57_1 = {
   3404    { nir_search_value_variable, 0 },
   3405    1, /* b */
   3406    false,
   3407    nir_type_invalid,
   3408    NULL,
   3409 };
   3410 
   3411 #include "compiler/nir/nir_search_helpers.h"
   3412 static const nir_search_variable search57_2 = {
   3413    { nir_search_value_variable, 0 },
   3414    2, /* c */
   3415    false,
   3416    nir_type_invalid,
   3417    NULL,
   3418 };
   3419 #include "compiler/nir/nir_search_helpers.h"
   3420 static const nir_search_expression search57 = {
   3421    { nir_search_value_expression, 0 },
   3422    false,
   3423    nir_op_ffma,
   3424    { &search57_0.value, &search57_1.value, &search57_2.value },
   3425    NULL,
   3426 };
   3427 
   3428 #include "compiler/nir/nir_search_helpers.h"
   3429 static const nir_search_variable replace57_0_0 = {
   3430    { nir_search_value_variable, 0 },
   3431    0, /* a */
   3432    false,
   3433    nir_type_invalid,
   3434    NULL,
   3435 };
   3436 
   3437 #include "compiler/nir/nir_search_helpers.h"
   3438 static const nir_search_variable replace57_0_1 = {
   3439    { nir_search_value_variable, 0 },
   3440    1, /* b */
   3441    false,
   3442    nir_type_invalid,
   3443    NULL,
   3444 };
   3445 #include "compiler/nir/nir_search_helpers.h"
   3446 static const nir_search_expression replace57_0 = {
   3447    { nir_search_value_expression, 0 },
   3448    false,
   3449    nir_op_fmul,
   3450    { &replace57_0_0.value, &replace57_0_1.value },
   3451    NULL,
   3452 };
   3453 
   3454 #include "compiler/nir/nir_search_helpers.h"
   3455 static const nir_search_variable replace57_1 = {
   3456    { nir_search_value_variable, 0 },
   3457    2, /* c */
   3458    false,
   3459    nir_type_invalid,
   3460    NULL,
   3461 };
   3462 #include "compiler/nir/nir_search_helpers.h"
   3463 static const nir_search_expression replace57 = {
   3464    { nir_search_value_expression, 0 },
   3465    false,
   3466    nir_op_fadd,
   3467    { &replace57_0.value, &replace57_1.value },
   3468    NULL,
   3469 };
   3470 
   3471 static const struct transform nir_opt_algebraic_ffma_xforms[] = {
   3472    { &search37, &replace37.value, 0 },
   3473    { &search38, &replace38.value, 0 },
   3474    { &search39, &replace39.value, 0 },
   3475    { &search40, &replace40.value, 0 },
   3476    { &search41, &replace41.value, 0 },
   3477    { &search57, &replace57.value, 7 },
   3478 };
   3479 
   3480 #include "compiler/nir/nir_search_helpers.h"
   3481 static const nir_search_variable search82_0 = {
   3482    { nir_search_value_variable, 0 },
   3483    0, /* a */
   3484    false,
   3485    nir_type_invalid,
   3486    NULL,
   3487 };
   3488 
   3489 #include "compiler/nir/nir_search_helpers.h"
   3490 static const nir_search_variable search82_1 = {
   3491    { nir_search_value_variable, 0 },
   3492    0, /* a */
   3493    false,
   3494    nir_type_invalid,
   3495    NULL,
   3496 };
   3497 #include "compiler/nir/nir_search_helpers.h"
   3498 static const nir_search_expression search82 = {
   3499    { nir_search_value_expression, 0 },
   3500    false,
   3501    nir_op_umin,
   3502    { &search82_0.value, &search82_1.value },
   3503    NULL,
   3504 };
   3505 
   3506 #include "compiler/nir/nir_search_helpers.h"
   3507 static const nir_search_variable replace82 = {
   3508    { nir_search_value_variable, 0 },
   3509    0, /* a */
   3510    false,
   3511    nir_type_invalid,
   3512    NULL,
   3513 };
   3514 
   3515 #include "compiler/nir/nir_search_helpers.h"
   3516 static const nir_search_variable search90_0_0_0_0 = {
   3517    { nir_search_value_variable, 0 },
   3518    0, /* a */
   3519    false,
   3520    nir_type_invalid,
   3521    NULL,
   3522 };
   3523 
   3524 #include "compiler/nir/nir_search_helpers.h"
   3525 static const nir_search_variable search90_0_0_0_1 = {
   3526    { nir_search_value_variable, 0 },
   3527    1, /* b */
   3528    false,
   3529    nir_type_invalid,
   3530    NULL,
   3531 };
   3532 #include "compiler/nir/nir_search_helpers.h"
   3533 static const nir_search_expression search90_0_0_0 = {
   3534    { nir_search_value_expression, 0 },
   3535    false,
   3536    nir_op_umax,
   3537    { &search90_0_0_0_0.value, &search90_0_0_0_1.value },
   3538    NULL,
   3539 };
   3540 
   3541 #include "compiler/nir/nir_search_helpers.h"
   3542 static const nir_search_variable search90_0_0_1 = {
   3543    { nir_search_value_variable, 0 },
   3544    2, /* c */
   3545    false,
   3546    nir_type_invalid,
   3547    NULL,
   3548 };
   3549 #include "compiler/nir/nir_search_helpers.h"
   3550 static const nir_search_expression search90_0_0 = {
   3551    { nir_search_value_expression, 0 },
   3552    false,
   3553    nir_op_umin,
   3554    { &search90_0_0_0.value, &search90_0_0_1.value },
   3555    NULL,
   3556 };
   3557 
   3558 #include "compiler/nir/nir_search_helpers.h"
   3559 static const nir_search_variable search90_0_1 = {
   3560    { nir_search_value_variable, 0 },
   3561    1, /* b */
   3562    false,
   3563    nir_type_invalid,
   3564    NULL,
   3565 };
   3566 #include "compiler/nir/nir_search_helpers.h"
   3567 static const nir_search_expression search90_0 = {
   3568    { nir_search_value_expression, 0 },
   3569    false,
   3570    nir_op_umax,
   3571    { &search90_0_0.value, &search90_0_1.value },
   3572    NULL,
   3573 };
   3574 
   3575 #include "compiler/nir/nir_search_helpers.h"
   3576 static const nir_search_variable search90_1 = {
   3577    { nir_search_value_variable, 0 },
   3578    2, /* c */
   3579    false,
   3580    nir_type_invalid,
   3581    NULL,
   3582 };
   3583 #include "compiler/nir/nir_search_helpers.h"
   3584 static const nir_search_expression search90 = {
   3585    { nir_search_value_expression, 0 },
   3586    false,
   3587    nir_op_umin,
   3588    { &search90_0.value, &search90_1.value },
   3589    NULL,
   3590 };
   3591 
   3592 #include "compiler/nir/nir_search_helpers.h"
   3593 static const nir_search_variable replace90_0_0 = {
   3594    { nir_search_value_variable, 0 },
   3595    0, /* a */
   3596    false,
   3597    nir_type_invalid,
   3598    NULL,
   3599 };
   3600 
   3601 #include "compiler/nir/nir_search_helpers.h"
   3602 static const nir_search_variable replace90_0_1 = {
   3603    { nir_search_value_variable, 0 },
   3604    1, /* b */
   3605    false,
   3606    nir_type_invalid,
   3607    NULL,
   3608 };
   3609 #include "compiler/nir/nir_search_helpers.h"
   3610 static const nir_search_expression replace90_0 = {
   3611    { nir_search_value_expression, 0 },
   3612    false,
   3613    nir_op_umax,
   3614    { &replace90_0_0.value, &replace90_0_1.value },
   3615    NULL,
   3616 };
   3617 
   3618 #include "compiler/nir/nir_search_helpers.h"
   3619 static const nir_search_variable replace90_1 = {
   3620    { nir_search_value_variable, 0 },
   3621    2, /* c */
   3622    false,
   3623    nir_type_invalid,
   3624    NULL,
   3625 };
   3626 #include "compiler/nir/nir_search_helpers.h"
   3627 static const nir_search_expression replace90 = {
   3628    { nir_search_value_expression, 0 },
   3629    false,
   3630    nir_op_umin,
   3631    { &replace90_0.value, &replace90_1.value },
   3632    NULL,
   3633 };
   3634 
   3635 static const struct transform nir_opt_algebraic_umin_xforms[] = {
   3636    { &search82, &replace82.value, 0 },
   3637    { &search90, &replace90.value, 0 },
   3638 };
   3639 
   3640 #include "compiler/nir/nir_search_helpers.h"
   3641 static const nir_search_variable search83_0 = {
   3642    { nir_search_value_variable, 0 },
   3643    0, /* a */
   3644    false,
   3645    nir_type_invalid,
   3646    NULL,
   3647 };
   3648 
   3649 #include "compiler/nir/nir_search_helpers.h"
   3650 static const nir_search_variable search83_1 = {
   3651    { nir_search_value_variable, 0 },
   3652    0, /* a */
   3653    false,
   3654    nir_type_invalid,
   3655    NULL,
   3656 };
   3657 #include "compiler/nir/nir_search_helpers.h"
   3658 static const nir_search_expression search83 = {
   3659    { nir_search_value_expression, 0 },
   3660    false,
   3661    nir_op_umax,
   3662    { &search83_0.value, &search83_1.value },
   3663    NULL,
   3664 };
   3665 
   3666 #include "compiler/nir/nir_search_helpers.h"
   3667 static const nir_search_variable replace83 = {
   3668    { nir_search_value_variable, 0 },
   3669    0, /* a */
   3670    false,
   3671    nir_type_invalid,
   3672    NULL,
   3673 };
   3674 
   3675 static const struct transform nir_opt_algebraic_umax_xforms[] = {
   3676    { &search83, &replace83.value, 0 },
   3677 };
   3678 
   3679 #include "compiler/nir/nir_search_helpers.h"
   3680 static const nir_search_variable search73_0_0 = {
   3681    { nir_search_value_variable, 0 },
   3682    0, /* b */
   3683    false,
   3684    nir_type_invalid,
   3685    NULL,
   3686 };
   3687 
   3688 #include "compiler/nir/nir_search_helpers.h"
   3689 static const nir_search_variable search73_0_1 = {
   3690    { nir_search_value_variable, 0 },
   3691    1, /* a */
   3692    false,
   3693    nir_type_invalid,
   3694    NULL,
   3695 };
   3696 #include "compiler/nir/nir_search_helpers.h"
   3697 static const nir_search_expression search73_0 = {
   3698    { nir_search_value_expression, 0 },
   3699    false,
   3700    nir_op_flt,
   3701    { &search73_0_0.value, &search73_0_1.value },
   3702    NULL,
   3703 };
   3704 
   3705 #include "compiler/nir/nir_search_helpers.h"
   3706 static const nir_search_variable search73_1 = {
   3707    { nir_search_value_variable, 0 },
   3708    0, /* b */
   3709    false,
   3710    nir_type_invalid,
   3711    NULL,
   3712 };
   3713 
   3714 #include "compiler/nir/nir_search_helpers.h"
   3715 static const nir_search_variable search73_2 = {
   3716    { nir_search_value_variable, 0 },
   3717    1, /* a */
   3718    false,
   3719    nir_type_invalid,
   3720    NULL,
   3721 };
   3722 #include "compiler/nir/nir_search_helpers.h"
   3723 static const nir_search_expression search73 = {
   3724    { nir_search_value_expression, 0 },
   3725    false,
   3726    nir_op_bcsel,
   3727    { &search73_0.value, &search73_1.value, &search73_2.value },
   3728    NULL,
   3729 };
   3730 
   3731 #include "compiler/nir/nir_search_helpers.h"
   3732 static const nir_search_variable replace73_0 = {
   3733    { nir_search_value_variable, 0 },
   3734    1, /* a */
   3735    false,
   3736    nir_type_invalid,
   3737    NULL,
   3738 };
   3739 
   3740 #include "compiler/nir/nir_search_helpers.h"
   3741 static const nir_search_variable replace73_1 = {
   3742    { nir_search_value_variable, 0 },
   3743    0, /* b */
   3744    false,
   3745    nir_type_invalid,
   3746    NULL,
   3747 };
   3748 #include "compiler/nir/nir_search_helpers.h"
   3749 static const nir_search_expression replace73 = {
   3750    { nir_search_value_expression, 0 },
   3751    false,
   3752    nir_op_fmin,
   3753    { &replace73_0.value, &replace73_1.value },
   3754    NULL,
   3755 };
   3756 
   3757 #include "compiler/nir/nir_search_helpers.h"
   3758 static const nir_search_variable search74_0_0 = {
   3759    { nir_search_value_variable, 0 },
   3760    0, /* a */
   3761    false,
   3762    nir_type_invalid,
   3763    NULL,
   3764 };
   3765 
   3766 #include "compiler/nir/nir_search_helpers.h"
   3767 static const nir_search_variable search74_0_1 = {
   3768    { nir_search_value_variable, 0 },
   3769    1, /* b */
   3770    false,
   3771    nir_type_invalid,
   3772    NULL,
   3773 };
   3774 #include "compiler/nir/nir_search_helpers.h"
   3775 static const nir_search_expression search74_0 = {
   3776    { nir_search_value_expression, 0 },
   3777    false,
   3778    nir_op_flt,
   3779    { &search74_0_0.value, &search74_0_1.value },
   3780    NULL,
   3781 };
   3782 
   3783 #include "compiler/nir/nir_search_helpers.h"
   3784 static const nir_search_variable search74_1 = {
   3785    { nir_search_value_variable, 0 },
   3786    1, /* b */
   3787    false,
   3788    nir_type_invalid,
   3789    NULL,
   3790 };
   3791 
   3792 #include "compiler/nir/nir_search_helpers.h"
   3793 static const nir_search_variable search74_2 = {
   3794    { nir_search_value_variable, 0 },
   3795    0, /* a */
   3796    false,
   3797    nir_type_invalid,
   3798    NULL,
   3799 };
   3800 #include "compiler/nir/nir_search_helpers.h"
   3801 static const nir_search_expression search74 = {
   3802    { nir_search_value_expression, 0 },
   3803    false,
   3804    nir_op_bcsel,
   3805    { &search74_0.value, &search74_1.value, &search74_2.value },
   3806    NULL,
   3807 };
   3808 
   3809 #include "compiler/nir/nir_search_helpers.h"
   3810 static const nir_search_variable replace74_0 = {
   3811    { nir_search_value_variable, 0 },
   3812    0, /* a */
   3813    false,
   3814    nir_type_invalid,
   3815    NULL,
   3816 };
   3817 
   3818 #include "compiler/nir/nir_search_helpers.h"
   3819 static const nir_search_variable replace74_1 = {
   3820    { nir_search_value_variable, 0 },
   3821    1, /* b */
   3822    false,
   3823    nir_type_invalid,
   3824    NULL,
   3825 };
   3826 #include "compiler/nir/nir_search_helpers.h"
   3827 static const nir_search_expression replace74 = {
   3828    { nir_search_value_expression, 0 },
   3829    false,
   3830    nir_op_fmax,
   3831    { &replace74_0.value, &replace74_1.value },
   3832    NULL,
   3833 };
   3834 
   3835 #include "compiler/nir/nir_search_helpers.h"
   3836 static const nir_search_variable search75_0_0 = {
   3837    { nir_search_value_variable, 0 },
   3838    0, /* a */
   3839    false,
   3840    nir_type_invalid,
   3841    NULL,
   3842 };
   3843 #include "compiler/nir/nir_search_helpers.h"
   3844 static const nir_search_expression search75_0 = {
   3845    { nir_search_value_expression, 0 },
   3846    false,
   3847    nir_op_inot,
   3848    { &search75_0_0.value },
   3849    NULL,
   3850 };
   3851 
   3852 #include "compiler/nir/nir_search_helpers.h"
   3853 static const nir_search_variable search75_1 = {
   3854    { nir_search_value_variable, 0 },
   3855    1, /* b */
   3856    false,
   3857    nir_type_invalid,
   3858    NULL,
   3859 };
   3860 
   3861 #include "compiler/nir/nir_search_helpers.h"
   3862 static const nir_search_variable search75_2 = {
   3863    { nir_search_value_variable, 0 },
   3864    2, /* c */
   3865    false,
   3866    nir_type_invalid,
   3867    NULL,
   3868 };
   3869 #include "compiler/nir/nir_search_helpers.h"
   3870 static const nir_search_expression search75 = {
   3871    { nir_search_value_expression, 0 },
   3872    false,
   3873    nir_op_bcsel,
   3874    { &search75_0.value, &search75_1.value, &search75_2.value },
   3875    NULL,
   3876 };
   3877 
   3878 #include "compiler/nir/nir_search_helpers.h"
   3879 static const nir_search_variable replace75_0 = {
   3880    { nir_search_value_variable, 0 },
   3881    0, /* a */
   3882    false,
   3883    nir_type_invalid,
   3884    NULL,
   3885 };
   3886 
   3887 #include "compiler/nir/nir_search_helpers.h"
   3888 static const nir_search_variable replace75_1 = {
   3889    { nir_search_value_variable, 0 },
   3890    2, /* c */
   3891    false,
   3892    nir_type_invalid,
   3893    NULL,
   3894 };
   3895 
   3896 #include "compiler/nir/nir_search_helpers.h"
   3897 static const nir_search_variable replace75_2 = {
   3898    { nir_search_value_variable, 0 },
   3899    1, /* b */
   3900    false,
   3901    nir_type_invalid,
   3902    NULL,
   3903 };
   3904 #include "compiler/nir/nir_search_helpers.h"
   3905 static const nir_search_expression replace75 = {
   3906    { nir_search_value_expression, 0 },
   3907    false,
   3908    nir_op_bcsel,
   3909    { &replace75_0.value, &replace75_1.value, &replace75_2.value },
   3910    NULL,
   3911 };
   3912 
   3913 #include "compiler/nir/nir_search_helpers.h"
   3914 static const nir_search_variable search76_0 = {
   3915    { nir_search_value_variable, 0 },
   3916    0, /* a */
   3917    false,
   3918    nir_type_invalid,
   3919    NULL,
   3920 };
   3921 
   3922 #include "compiler/nir/nir_search_helpers.h"
   3923 static const nir_search_variable search76_1_0 = {
   3924    { nir_search_value_variable, 0 },
   3925    0, /* a */
   3926    false,
   3927    nir_type_invalid,
   3928    NULL,
   3929 };
   3930 
   3931 #include "compiler/nir/nir_search_helpers.h"
   3932 static const nir_search_variable search76_1_1 = {
   3933    { nir_search_value_variable, 0 },
   3934    1, /* b */
   3935    false,
   3936    nir_type_invalid,
   3937    NULL,
   3938 };
   3939 
   3940 #include "compiler/nir/nir_search_helpers.h"
   3941 static const nir_search_variable search76_1_2 = {
   3942    { nir_search_value_variable, 0 },
   3943    2, /* c */
   3944    false,
   3945    nir_type_invalid,
   3946    NULL,
   3947 };
   3948 #include "compiler/nir/nir_search_helpers.h"
   3949 static const nir_search_expression search76_1 = {
   3950    { nir_search_value_expression, 0 },
   3951    false,
   3952    nir_op_bcsel,
   3953    { &search76_1_0.value, &search76_1_1.value, &search76_1_2.value },
   3954    NULL,
   3955 };
   3956 
   3957 #include "compiler/nir/nir_search_helpers.h"
   3958 static const nir_search_variable search76_2 = {
   3959    { nir_search_value_variable, 0 },
   3960    3, /* d */
   3961    false,
   3962    nir_type_invalid,
   3963    NULL,
   3964 };
   3965 #include "compiler/nir/nir_search_helpers.h"
   3966 static const nir_search_expression search76 = {
   3967    { nir_search_value_expression, 0 },
   3968    false,
   3969    nir_op_bcsel,
   3970    { &search76_0.value, &search76_1.value, &search76_2.value },
   3971    NULL,
   3972 };
   3973 
   3974 #include "compiler/nir/nir_search_helpers.h"
   3975 static const nir_search_variable replace76_0 = {
   3976    { nir_search_value_variable, 0 },
   3977    0, /* a */
   3978    false,
   3979    nir_type_invalid,
   3980    NULL,
   3981 };
   3982 
   3983 #include "compiler/nir/nir_search_helpers.h"
   3984 static const nir_search_variable replace76_1 = {
   3985    { nir_search_value_variable, 0 },
   3986    1, /* b */
   3987    false,
   3988    nir_type_invalid,
   3989    NULL,
   3990 };
   3991 
   3992 #include "compiler/nir/nir_search_helpers.h"
   3993 static const nir_search_variable replace76_2 = {
   3994    { nir_search_value_variable, 0 },
   3995    3, /* d */
   3996    false,
   3997    nir_type_invalid,
   3998    NULL,
   3999 };
   4000 #include "compiler/nir/nir_search_helpers.h"
   4001 static const nir_search_expression replace76 = {
   4002    { nir_search_value_expression, 0 },
   4003    false,
   4004    nir_op_bcsel,
   4005    { &replace76_0.value, &replace76_1.value, &replace76_2.value },
   4006    NULL,
   4007 };
   4008 
   4009 #include "compiler/nir/nir_search_helpers.h"
   4010 static const nir_search_variable search77_0 = {
   4011    { nir_search_value_variable, 0 },
   4012    0, /* a */
   4013    false,
   4014    nir_type_invalid,
   4015    NULL,
   4016 };
   4017 
   4018 #include "compiler/nir/nir_search_helpers.h"
   4019 static const nir_search_constant search77_1 = {
   4020    { nir_search_value_constant, 32 },
   4021    nir_type_bool32, { NIR_TRUE /* True */ },
   4022 };
   4023 
   4024 #include "compiler/nir/nir_search_helpers.h"
   4025 static const nir_search_variable search77_2 = {
   4026    { nir_search_value_variable, 32 },
   4027    1, /* b */
   4028    false,
   4029    nir_type_bool32,
   4030    NULL,
   4031 };
   4032 #include "compiler/nir/nir_search_helpers.h"
   4033 static const nir_search_expression search77 = {
   4034    { nir_search_value_expression, 0 },
   4035    false,
   4036    nir_op_bcsel,
   4037    { &search77_0.value, &search77_1.value, &search77_2.value },
   4038    NULL,
   4039 };
   4040 
   4041 #include "compiler/nir/nir_search_helpers.h"
   4042 static const nir_search_variable replace77_0 = {
   4043    { nir_search_value_variable, 0 },
   4044    0, /* a */
   4045    false,
   4046    nir_type_invalid,
   4047    NULL,
   4048 };
   4049 
   4050 #include "compiler/nir/nir_search_helpers.h"
   4051 static const nir_search_variable replace77_1 = {
   4052    { nir_search_value_variable, 0 },
   4053    1, /* b */
   4054    false,
   4055    nir_type_invalid,
   4056    NULL,
   4057 };
   4058 #include "compiler/nir/nir_search_helpers.h"
   4059 static const nir_search_expression replace77 = {
   4060    { nir_search_value_expression, 0 },
   4061    false,
   4062    nir_op_ior,
   4063    { &replace77_0.value, &replace77_1.value },
   4064    NULL,
   4065 };
   4066 
   4067 #include "compiler/nir/nir_search_helpers.h"
   4068 static const nir_search_variable search171_0 = {
   4069    { nir_search_value_variable, 0 },
   4070    0, /* a */
   4071    false,
   4072    nir_type_invalid,
   4073    NULL,
   4074 };
   4075 
   4076 #include "compiler/nir/nir_search_helpers.h"
   4077 static const nir_search_constant search171_1 = {
   4078    { nir_search_value_constant, 32 },
   4079    nir_type_bool32, { NIR_TRUE /* True */ },
   4080 };
   4081 
   4082 #include "compiler/nir/nir_search_helpers.h"
   4083 static const nir_search_constant search171_2 = {
   4084    { nir_search_value_constant, 32 },
   4085    nir_type_bool32, { NIR_FALSE /* False */ },
   4086 };
   4087 #include "compiler/nir/nir_search_helpers.h"
   4088 static const nir_search_expression search171 = {
   4089    { nir_search_value_expression, 0 },
   4090    false,
   4091    nir_op_bcsel,
   4092    { &search171_0.value, &search171_1.value, &search171_2.value },
   4093    NULL,
   4094 };
   4095 
   4096 #include "compiler/nir/nir_search_helpers.h"
   4097 static const nir_search_variable replace171 = {
   4098    { nir_search_value_variable, 0 },
   4099    0, /* a */
   4100    false,
   4101    nir_type_invalid,
   4102    NULL,
   4103 };
   4104 
   4105 #include "compiler/nir/nir_search_helpers.h"
   4106 static const nir_search_variable search172_0 = {
   4107    { nir_search_value_variable, 0 },
   4108    0, /* a */
   4109    false,
   4110    nir_type_invalid,
   4111    NULL,
   4112 };
   4113 
   4114 #include "compiler/nir/nir_search_helpers.h"
   4115 static const nir_search_constant search172_1 = {
   4116    { nir_search_value_constant, 32 },
   4117    nir_type_bool32, { NIR_FALSE /* False */ },
   4118 };
   4119 
   4120 #include "compiler/nir/nir_search_helpers.h"
   4121 static const nir_search_constant search172_2 = {
   4122    { nir_search_value_constant, 32 },
   4123    nir_type_bool32, { NIR_TRUE /* True */ },
   4124 };
   4125 #include "compiler/nir/nir_search_helpers.h"
   4126 static const nir_search_expression search172 = {
   4127    { nir_search_value_expression, 0 },
   4128    false,
   4129    nir_op_bcsel,
   4130    { &search172_0.value, &search172_1.value, &search172_2.value },
   4131    NULL,
   4132 };
   4133 
   4134 #include "compiler/nir/nir_search_helpers.h"
   4135 static const nir_search_variable replace172_0 = {
   4136    { nir_search_value_variable, 0 },
   4137    0, /* a */
   4138    false,
   4139    nir_type_invalid,
   4140    NULL,
   4141 };
   4142 #include "compiler/nir/nir_search_helpers.h"
   4143 static const nir_search_expression replace172 = {
   4144    { nir_search_value_expression, 0 },
   4145    false,
   4146    nir_op_inot,
   4147    { &replace172_0.value },
   4148    NULL,
   4149 };
   4150 
   4151 #include "compiler/nir/nir_search_helpers.h"
   4152 static const nir_search_variable search173_0 = {
   4153    { nir_search_value_variable, 0 },
   4154    0, /* a */
   4155    false,
   4156    nir_type_invalid,
   4157    NULL,
   4158 };
   4159 
   4160 #include "compiler/nir/nir_search_helpers.h"
   4161 static const nir_search_constant search173_1 = {
   4162    { nir_search_value_constant, 0 },
   4163    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   4164 };
   4165 
   4166 #include "compiler/nir/nir_search_helpers.h"
   4167 static const nir_search_constant search173_2 = {
   4168    { nir_search_value_constant, 0 },
   4169    nir_type_float, { 0x0 /* 0.0 */ },
   4170 };
   4171 #include "compiler/nir/nir_search_helpers.h"
   4172 static const nir_search_expression search173 = {
   4173    { nir_search_value_expression, 32 },
   4174    false,
   4175    nir_op_bcsel,
   4176    { &search173_0.value, &search173_1.value, &search173_2.value },
   4177    NULL,
   4178 };
   4179 
   4180 #include "compiler/nir/nir_search_helpers.h"
   4181 static const nir_search_variable replace173_0 = {
   4182    { nir_search_value_variable, 0 },
   4183    0, /* a */
   4184    false,
   4185    nir_type_invalid,
   4186    NULL,
   4187 };
   4188 #include "compiler/nir/nir_search_helpers.h"
   4189 static const nir_search_expression replace173 = {
   4190    { nir_search_value_expression, 0 },
   4191    false,
   4192    nir_op_b2f,
   4193    { &replace173_0.value },
   4194    NULL,
   4195 };
   4196 
   4197 #include "compiler/nir/nir_search_helpers.h"
   4198 static const nir_search_variable search174_0 = {
   4199    { nir_search_value_variable, 0 },
   4200    0, /* a */
   4201    false,
   4202    nir_type_invalid,
   4203    NULL,
   4204 };
   4205 
   4206 #include "compiler/nir/nir_search_helpers.h"
   4207 static const nir_search_constant search174_1 = {
   4208    { nir_search_value_constant, 0 },
   4209    nir_type_float, { 0x0 /* 0.0 */ },
   4210 };
   4211 
   4212 #include "compiler/nir/nir_search_helpers.h"
   4213 static const nir_search_constant search174_2 = {
   4214    { nir_search_value_constant, 0 },
   4215    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   4216 };
   4217 #include "compiler/nir/nir_search_helpers.h"
   4218 static const nir_search_expression search174 = {
   4219    { nir_search_value_expression, 32 },
   4220    false,
   4221    nir_op_bcsel,
   4222    { &search174_0.value, &search174_1.value, &search174_2.value },
   4223    NULL,
   4224 };
   4225 
   4226 #include "compiler/nir/nir_search_helpers.h"
   4227 static const nir_search_variable replace174_0_0 = {
   4228    { nir_search_value_variable, 0 },
   4229    0, /* a */
   4230    false,
   4231    nir_type_invalid,
   4232    NULL,
   4233 };
   4234 #include "compiler/nir/nir_search_helpers.h"
   4235 static const nir_search_expression replace174_0 = {
   4236    { nir_search_value_expression, 0 },
   4237    false,
   4238    nir_op_inot,
   4239    { &replace174_0_0.value },
   4240    NULL,
   4241 };
   4242 #include "compiler/nir/nir_search_helpers.h"
   4243 static const nir_search_expression replace174 = {
   4244    { nir_search_value_expression, 0 },
   4245    false,
   4246    nir_op_b2f,
   4247    { &replace174_0.value },
   4248    NULL,
   4249 };
   4250 
   4251 #include "compiler/nir/nir_search_helpers.h"
   4252 static const nir_search_variable search175_0 = {
   4253    { nir_search_value_variable, 0 },
   4254    0, /* a */
   4255    false,
   4256    nir_type_invalid,
   4257    NULL,
   4258 };
   4259 
   4260 #include "compiler/nir/nir_search_helpers.h"
   4261 static const nir_search_constant search175_1 = {
   4262    { nir_search_value_constant, 0 },
   4263    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   4264 };
   4265 
   4266 #include "compiler/nir/nir_search_helpers.h"
   4267 static const nir_search_constant search175_2 = {
   4268    { nir_search_value_constant, 0 },
   4269    nir_type_float, { 0x8000000000000000L /* -0.0 */ },
   4270 };
   4271 #include "compiler/nir/nir_search_helpers.h"
   4272 static const nir_search_expression search175 = {
   4273    { nir_search_value_expression, 32 },
   4274    false,
   4275    nir_op_bcsel,
   4276    { &search175_0.value, &search175_1.value, &search175_2.value },
   4277    NULL,
   4278 };
   4279 
   4280 #include "compiler/nir/nir_search_helpers.h"
   4281 static const nir_search_variable replace175_0_0 = {
   4282    { nir_search_value_variable, 0 },
   4283    0, /* a */
   4284    false,
   4285    nir_type_invalid,
   4286    NULL,
   4287 };
   4288 #include "compiler/nir/nir_search_helpers.h"
   4289 static const nir_search_expression replace175_0 = {
   4290    { nir_search_value_expression, 0 },
   4291    false,
   4292    nir_op_b2f,
   4293    { &replace175_0_0.value },
   4294    NULL,
   4295 };
   4296 #include "compiler/nir/nir_search_helpers.h"
   4297 static const nir_search_expression replace175 = {
   4298    { nir_search_value_expression, 0 },
   4299    false,
   4300    nir_op_fneg,
   4301    { &replace175_0.value },
   4302    NULL,
   4303 };
   4304 
   4305 #include "compiler/nir/nir_search_helpers.h"
   4306 static const nir_search_variable search176_0 = {
   4307    { nir_search_value_variable, 0 },
   4308    0, /* a */
   4309    false,
   4310    nir_type_invalid,
   4311    NULL,
   4312 };
   4313 
   4314 #include "compiler/nir/nir_search_helpers.h"
   4315 static const nir_search_constant search176_1 = {
   4316    { nir_search_value_constant, 0 },
   4317    nir_type_float, { 0x8000000000000000L /* -0.0 */ },
   4318 };
   4319 
   4320 #include "compiler/nir/nir_search_helpers.h"
   4321 static const nir_search_constant search176_2 = {
   4322    { nir_search_value_constant, 0 },
   4323    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   4324 };
   4325 #include "compiler/nir/nir_search_helpers.h"
   4326 static const nir_search_expression search176 = {
   4327    { nir_search_value_expression, 32 },
   4328    false,
   4329    nir_op_bcsel,
   4330    { &search176_0.value, &search176_1.value, &search176_2.value },
   4331    NULL,
   4332 };
   4333 
   4334 #include "compiler/nir/nir_search_helpers.h"
   4335 static const nir_search_variable replace176_0_0_0 = {
   4336    { nir_search_value_variable, 0 },
   4337    0, /* a */
   4338    false,
   4339    nir_type_invalid,
   4340    NULL,
   4341 };
   4342 #include "compiler/nir/nir_search_helpers.h"
   4343 static const nir_search_expression replace176_0_0 = {
   4344    { nir_search_value_expression, 0 },
   4345    false,
   4346    nir_op_inot,
   4347    { &replace176_0_0_0.value },
   4348    NULL,
   4349 };
   4350 #include "compiler/nir/nir_search_helpers.h"
   4351 static const nir_search_expression replace176_0 = {
   4352    { nir_search_value_expression, 0 },
   4353    false,
   4354    nir_op_b2f,
   4355    { &replace176_0_0.value },
   4356    NULL,
   4357 };
   4358 #include "compiler/nir/nir_search_helpers.h"
   4359 static const nir_search_expression replace176 = {
   4360    { nir_search_value_expression, 0 },
   4361    false,
   4362    nir_op_fneg,
   4363    { &replace176_0.value },
   4364    NULL,
   4365 };
   4366 
   4367 #include "compiler/nir/nir_search_helpers.h"
   4368 static const nir_search_constant search177_0 = {
   4369    { nir_search_value_constant, 32 },
   4370    nir_type_bool32, { NIR_TRUE /* True */ },
   4371 };
   4372 
   4373 #include "compiler/nir/nir_search_helpers.h"
   4374 static const nir_search_variable search177_1 = {
   4375    { nir_search_value_variable, 0 },
   4376    0, /* b */
   4377    false,
   4378    nir_type_invalid,
   4379    NULL,
   4380 };
   4381 
   4382 #include "compiler/nir/nir_search_helpers.h"
   4383 static const nir_search_variable search177_2 = {
   4384    { nir_search_value_variable, 0 },
   4385    1, /* c */
   4386    false,
   4387    nir_type_invalid,
   4388    NULL,
   4389 };
   4390 #include "compiler/nir/nir_search_helpers.h"
   4391 static const nir_search_expression search177 = {
   4392    { nir_search_value_expression, 0 },
   4393    false,
   4394    nir_op_bcsel,
   4395    { &search177_0.value, &search177_1.value, &search177_2.value },
   4396    NULL,
   4397 };
   4398 
   4399 #include "compiler/nir/nir_search_helpers.h"
   4400 static const nir_search_variable replace177 = {
   4401    { nir_search_value_variable, 0 },
   4402    0, /* b */
   4403    false,
   4404    nir_type_invalid,
   4405    NULL,
   4406 };
   4407 
   4408 #include "compiler/nir/nir_search_helpers.h"
   4409 static const nir_search_constant search178_0 = {
   4410    { nir_search_value_constant, 32 },
   4411    nir_type_bool32, { NIR_FALSE /* False */ },
   4412 };
   4413 
   4414 #include "compiler/nir/nir_search_helpers.h"
   4415 static const nir_search_variable search178_1 = {
   4416    { nir_search_value_variable, 0 },
   4417    0, /* b */
   4418    false,
   4419    nir_type_invalid,
   4420    NULL,
   4421 };
   4422 
   4423 #include "compiler/nir/nir_search_helpers.h"
   4424 static const nir_search_variable search178_2 = {
   4425    { nir_search_value_variable, 0 },
   4426    1, /* c */
   4427    false,
   4428    nir_type_invalid,
   4429    NULL,
   4430 };
   4431 #include "compiler/nir/nir_search_helpers.h"
   4432 static const nir_search_expression search178 = {
   4433    { nir_search_value_expression, 0 },
   4434    false,
   4435    nir_op_bcsel,
   4436    { &search178_0.value, &search178_1.value, &search178_2.value },
   4437    NULL,
   4438 };
   4439 
   4440 #include "compiler/nir/nir_search_helpers.h"
   4441 static const nir_search_variable replace178 = {
   4442    { nir_search_value_variable, 0 },
   4443    1, /* c */
   4444    false,
   4445    nir_type_invalid,
   4446    NULL,
   4447 };
   4448 
   4449 #include "compiler/nir/nir_search_helpers.h"
   4450 static const nir_search_variable search179_0 = {
   4451    { nir_search_value_variable, 0 },
   4452    0, /* a */
   4453    true,
   4454    nir_type_invalid,
   4455    NULL,
   4456 };
   4457 
   4458 #include "compiler/nir/nir_search_helpers.h"
   4459 static const nir_search_variable search179_1 = {
   4460    { nir_search_value_variable, 0 },
   4461    1, /* b */
   4462    false,
   4463    nir_type_invalid,
   4464    NULL,
   4465 };
   4466 
   4467 #include "compiler/nir/nir_search_helpers.h"
   4468 static const nir_search_variable search179_2 = {
   4469    { nir_search_value_variable, 0 },
   4470    2, /* c */
   4471    false,
   4472    nir_type_invalid,
   4473    NULL,
   4474 };
   4475 #include "compiler/nir/nir_search_helpers.h"
   4476 static const nir_search_expression search179 = {
   4477    { nir_search_value_expression, 0 },
   4478    false,
   4479    nir_op_bcsel,
   4480    { &search179_0.value, &search179_1.value, &search179_2.value },
   4481    NULL,
   4482 };
   4483 
   4484 #include "compiler/nir/nir_search_helpers.h"
   4485 static const nir_search_variable replace179_0_0 = {
   4486    { nir_search_value_variable, 0 },
   4487    0, /* a */
   4488    false,
   4489    nir_type_invalid,
   4490    NULL,
   4491 };
   4492 
   4493 #include "compiler/nir/nir_search_helpers.h"
   4494 static const nir_search_constant replace179_0_1 = {
   4495    { nir_search_value_constant, 0 },
   4496    nir_type_int, { 0x0 /* 0 */ },
   4497 };
   4498 #include "compiler/nir/nir_search_helpers.h"
   4499 static const nir_search_expression replace179_0 = {
   4500    { nir_search_value_expression, 0 },
   4501    false,
   4502    nir_op_ine,
   4503    { &replace179_0_0.value, &replace179_0_1.value },
   4504    NULL,
   4505 };
   4506 
   4507 #include "compiler/nir/nir_search_helpers.h"
   4508 static const nir_search_variable replace179_1 = {
   4509    { nir_search_value_variable, 0 },
   4510    1, /* b */
   4511    false,
   4512    nir_type_invalid,
   4513    NULL,
   4514 };
   4515 
   4516 #include "compiler/nir/nir_search_helpers.h"
   4517 static const nir_search_variable replace179_2 = {
   4518    { nir_search_value_variable, 0 },
   4519    2, /* c */
   4520    false,
   4521    nir_type_invalid,
   4522    NULL,
   4523 };
   4524 #include "compiler/nir/nir_search_helpers.h"
   4525 static const nir_search_expression replace179 = {
   4526    { nir_search_value_expression, 0 },
   4527    false,
   4528    nir_op_bcsel,
   4529    { &replace179_0.value, &replace179_1.value, &replace179_2.value },
   4530    NULL,
   4531 };
   4532 
   4533 #include "compiler/nir/nir_search_helpers.h"
   4534 static const nir_search_variable search180_0 = {
   4535    { nir_search_value_variable, 0 },
   4536    0, /* a */
   4537    false,
   4538    nir_type_invalid,
   4539    NULL,
   4540 };
   4541 
   4542 #include "compiler/nir/nir_search_helpers.h"
   4543 static const nir_search_variable search180_1 = {
   4544    { nir_search_value_variable, 0 },
   4545    1, /* b */
   4546    false,
   4547    nir_type_invalid,
   4548    NULL,
   4549 };
   4550 
   4551 #include "compiler/nir/nir_search_helpers.h"
   4552 static const nir_search_variable search180_2 = {
   4553    { nir_search_value_variable, 0 },
   4554    1, /* b */
   4555    false,
   4556    nir_type_invalid,
   4557    NULL,
   4558 };
   4559 #include "compiler/nir/nir_search_helpers.h"
   4560 static const nir_search_expression search180 = {
   4561    { nir_search_value_expression, 0 },
   4562    false,
   4563    nir_op_bcsel,
   4564    { &search180_0.value, &search180_1.value, &search180_2.value },
   4565    NULL,
   4566 };
   4567 
   4568 #include "compiler/nir/nir_search_helpers.h"
   4569 static const nir_search_variable replace180 = {
   4570    { nir_search_value_variable, 0 },
   4571    1, /* b */
   4572    false,
   4573    nir_type_invalid,
   4574    NULL,
   4575 };
   4576 
   4577 static const struct transform nir_opt_algebraic_bcsel_xforms[] = {
   4578    { &search73, &replace73.value, 0 },
   4579    { &search74, &replace74.value, 0 },
   4580    { &search75, &replace75.value, 0 },
   4581    { &search76, &replace76.value, 0 },
   4582    { &search77, &replace77.value, 0 },
   4583    { &search171, &replace171.value, 0 },
   4584    { &search172, &replace172.value, 0 },
   4585    { &search173, &replace173.value, 0 },
   4586    { &search174, &replace174.value, 0 },
   4587    { &search175, &replace175.value, 0 },
   4588    { &search176, &replace176.value, 0 },
   4589    { &search177, &replace177.value, 0 },
   4590    { &search178, &replace178.value, 0 },
   4591    { &search179, &replace179.value, 0 },
   4592    { &search180, &replace180.value, 0 },
   4593 };
   4594 
   4595 #include "compiler/nir/nir_search_helpers.h"
   4596 static const nir_search_variable search103_0 = {
   4597    { nir_search_value_variable, 0 },
   4598    0, /* a */
   4599    false,
   4600    nir_type_invalid,
   4601    NULL,
   4602 };
   4603 
   4604 #include "compiler/nir/nir_search_helpers.h"
   4605 static const nir_search_variable search103_1 = {
   4606    { nir_search_value_variable, 0 },
   4607    1, /* b */
   4608    false,
   4609    nir_type_invalid,
   4610    NULL,
   4611 };
   4612 #include "compiler/nir/nir_search_helpers.h"
   4613 static const nir_search_expression search103 = {
   4614    { nir_search_value_expression, 0 },
   4615    false,
   4616    nir_op_sge,
   4617    { &search103_0.value, &search103_1.value },
   4618    NULL,
   4619 };
   4620 
   4621 #include "compiler/nir/nir_search_helpers.h"
   4622 static const nir_search_variable replace103_0_0 = {
   4623    { nir_search_value_variable, 0 },
   4624    0, /* a */
   4625    false,
   4626    nir_type_invalid,
   4627    NULL,
   4628 };
   4629 
   4630 #include "compiler/nir/nir_search_helpers.h"
   4631 static const nir_search_variable replace103_0_1 = {
   4632    { nir_search_value_variable, 0 },
   4633    1, /* b */
   4634    false,
   4635    nir_type_invalid,
   4636    NULL,
   4637 };
   4638 #include "compiler/nir/nir_search_helpers.h"
   4639 static const nir_search_expression replace103_0 = {
   4640    { nir_search_value_expression, 0 },
   4641    false,
   4642    nir_op_fge,
   4643    { &replace103_0_0.value, &replace103_0_1.value },
   4644    NULL,
   4645 };
   4646 #include "compiler/nir/nir_search_helpers.h"
   4647 static const nir_search_expression replace103 = {
   4648    { nir_search_value_expression, 0 },
   4649    false,
   4650    nir_op_b2f,
   4651    { &replace103_0.value },
   4652    NULL,
   4653 };
   4654 
   4655 static const struct transform nir_opt_algebraic_sge_xforms[] = {
   4656    { &search103, &replace103.value, 11 },
   4657 };
   4658 
   4659 #include "compiler/nir/nir_search_helpers.h"
   4660 static const nir_search_variable search153_0_0 = {
   4661    { nir_search_value_variable, 0 },
   4662    0, /* a */
   4663    false,
   4664    nir_type_invalid,
   4665    NULL,
   4666 };
   4667 #include "compiler/nir/nir_search_helpers.h"
   4668 static const nir_search_expression search153_0 = {
   4669    { nir_search_value_expression, 0 },
   4670    false,
   4671    nir_op_fexp2,
   4672    { &search153_0_0.value },
   4673    NULL,
   4674 };
   4675 #include "compiler/nir/nir_search_helpers.h"
   4676 static const nir_search_expression search153 = {
   4677    { nir_search_value_expression, 0 },
   4678    true,
   4679    nir_op_fsqrt,
   4680    { &search153_0.value },
   4681    NULL,
   4682 };
   4683 
   4684 #include "compiler/nir/nir_search_helpers.h"
   4685 static const nir_search_constant replace153_0_0 = {
   4686    { nir_search_value_constant, 0 },
   4687    nir_type_float, { 0x3fe0000000000000 /* 0.5 */ },
   4688 };
   4689 
   4690 #include "compiler/nir/nir_search_helpers.h"
   4691 static const nir_search_variable replace153_0_1 = {
   4692    { nir_search_value_variable, 0 },
   4693    0, /* a */
   4694    false,
   4695    nir_type_invalid,
   4696    NULL,
   4697 };
   4698 #include "compiler/nir/nir_search_helpers.h"
   4699 static const nir_search_expression replace153_0 = {
   4700    { nir_search_value_expression, 0 },
   4701    false,
   4702    nir_op_fmul,
   4703    { &replace153_0_0.value, &replace153_0_1.value },
   4704    NULL,
   4705 };
   4706 #include "compiler/nir/nir_search_helpers.h"
   4707 static const nir_search_expression replace153 = {
   4708    { nir_search_value_expression, 0 },
   4709    false,
   4710    nir_op_fexp2,
   4711    { &replace153_0.value },
   4712    NULL,
   4713 };
   4714 
   4715 #include "compiler/nir/nir_search_helpers.h"
   4716 static const nir_search_variable search165_0 = {
   4717    { nir_search_value_variable, 0 },
   4718    0, /* a */
   4719    false,
   4720    nir_type_invalid,
   4721    NULL,
   4722 };
   4723 #include "compiler/nir/nir_search_helpers.h"
   4724 static const nir_search_expression search165 = {
   4725    { nir_search_value_expression, 0 },
   4726    false,
   4727    nir_op_fsqrt,
   4728    { &search165_0.value },
   4729    NULL,
   4730 };
   4731 
   4732 #include "compiler/nir/nir_search_helpers.h"
   4733 static const nir_search_variable replace165_0_0 = {
   4734    { nir_search_value_variable, 0 },
   4735    0, /* a */
   4736    false,
   4737    nir_type_invalid,
   4738    NULL,
   4739 };
   4740 #include "compiler/nir/nir_search_helpers.h"
   4741 static const nir_search_expression replace165_0 = {
   4742    { nir_search_value_expression, 0 },
   4743    false,
   4744    nir_op_frsq,
   4745    { &replace165_0_0.value },
   4746    NULL,
   4747 };
   4748 #include "compiler/nir/nir_search_helpers.h"
   4749 static const nir_search_expression replace165 = {
   4750    { nir_search_value_expression, 0 },
   4751    false,
   4752    nir_op_frcp,
   4753    { &replace165_0.value },
   4754    NULL,
   4755 };
   4756 
   4757 static const struct transform nir_opt_algebraic_fsqrt_xforms[] = {
   4758    { &search153, &replace153.value, 0 },
   4759    { &search165, &replace165.value, 15 },
   4760 };
   4761 
   4762 #include "compiler/nir/nir_search_helpers.h"
   4763 static const nir_search_variable search18_0 = {
   4764    { nir_search_value_variable, 0 },
   4765    0, /* a */
   4766    false,
   4767    nir_type_invalid,
   4768    NULL,
   4769 };
   4770 
   4771 #include "compiler/nir/nir_search_helpers.h"
   4772 static const nir_search_constant search18_1 = {
   4773    { nir_search_value_constant, 0 },
   4774    nir_type_int, { 0x0 /* 0 */ },
   4775 };
   4776 #include "compiler/nir/nir_search_helpers.h"
   4777 static const nir_search_expression search18 = {
   4778    { nir_search_value_expression, 0 },
   4779    false,
   4780    nir_op_iadd,
   4781    { &search18_0.value, &search18_1.value },
   4782    NULL,
   4783 };
   4784 
   4785 #include "compiler/nir/nir_search_helpers.h"
   4786 static const nir_search_variable replace18 = {
   4787    { nir_search_value_variable, 0 },
   4788    0, /* a */
   4789    false,
   4790    nir_type_invalid,
   4791    NULL,
   4792 };
   4793 
   4794 #include "compiler/nir/nir_search_helpers.h"
   4795 static const nir_search_variable search22_0_0 = {
   4796    { nir_search_value_variable, 0 },
   4797    0, /* a */
   4798    false,
   4799    nir_type_invalid,
   4800    NULL,
   4801 };
   4802 
   4803 #include "compiler/nir/nir_search_helpers.h"
   4804 static const nir_search_variable search22_0_1 = {
   4805    { nir_search_value_variable, 0 },
   4806    1, /* b */
   4807    false,
   4808    nir_type_invalid,
   4809    NULL,
   4810 };
   4811 #include "compiler/nir/nir_search_helpers.h"
   4812 static const nir_search_expression search22_0 = {
   4813    { nir_search_value_expression, 0 },
   4814    false,
   4815    nir_op_imul,
   4816    { &search22_0_0.value, &search22_0_1.value },
   4817    NULL,
   4818 };
   4819 
   4820 #include "compiler/nir/nir_search_helpers.h"
   4821 static const nir_search_variable search22_1_0 = {
   4822    { nir_search_value_variable, 0 },
   4823    0, /* a */
   4824    false,
   4825    nir_type_invalid,
   4826    NULL,
   4827 };
   4828 
   4829 #include "compiler/nir/nir_search_helpers.h"
   4830 static const nir_search_variable search22_1_1 = {
   4831    { nir_search_value_variable, 0 },
   4832    2, /* c */
   4833    false,
   4834    nir_type_invalid,
   4835    NULL,
   4836 };
   4837 #include "compiler/nir/nir_search_helpers.h"
   4838 static const nir_search_expression search22_1 = {
   4839    { nir_search_value_expression, 0 },
   4840    false,
   4841    nir_op_imul,
   4842    { &search22_1_0.value, &search22_1_1.value },
   4843    NULL,
   4844 };
   4845 #include "compiler/nir/nir_search_helpers.h"
   4846 static const nir_search_expression search22 = {
   4847    { nir_search_value_expression, 0 },
   4848    false,
   4849    nir_op_iadd,
   4850    { &search22_0.value, &search22_1.value },
   4851    NULL,
   4852 };
   4853 
   4854 #include "compiler/nir/nir_search_helpers.h"
   4855 static const nir_search_variable replace22_0 = {
   4856    { nir_search_value_variable, 0 },
   4857    0, /* a */
   4858    false,
   4859    nir_type_invalid,
   4860    NULL,
   4861 };
   4862 
   4863 #include "compiler/nir/nir_search_helpers.h"
   4864 static const nir_search_variable replace22_1_0 = {
   4865    { nir_search_value_variable, 0 },
   4866    1, /* b */
   4867    false,
   4868    nir_type_invalid,
   4869    NULL,
   4870 };
   4871 
   4872 #include "compiler/nir/nir_search_helpers.h"
   4873 static const nir_search_variable replace22_1_1 = {
   4874    { nir_search_value_variable, 0 },
   4875    2, /* c */
   4876    false,
   4877    nir_type_invalid,
   4878    NULL,
   4879 };
   4880 #include "compiler/nir/nir_search_helpers.h"
   4881 static const nir_search_expression replace22_1 = {
   4882    { nir_search_value_expression, 0 },
   4883    false,
   4884    nir_op_iadd,
   4885    { &replace22_1_0.value, &replace22_1_1.value },
   4886    NULL,
   4887 };
   4888 #include "compiler/nir/nir_search_helpers.h"
   4889 static const nir_search_expression replace22 = {
   4890    { nir_search_value_expression, 0 },
   4891    false,
   4892    nir_op_imul,
   4893    { &replace22_0.value, &replace22_1.value },
   4894    NULL,
   4895 };
   4896 
   4897 #include "compiler/nir/nir_search_helpers.h"
   4898 static const nir_search_variable search24_0_0 = {
   4899    { nir_search_value_variable, 0 },
   4900    0, /* a */
   4901    false,
   4902    nir_type_invalid,
   4903    NULL,
   4904 };
   4905 #include "compiler/nir/nir_search_helpers.h"
   4906 static const nir_search_expression search24_0 = {
   4907    { nir_search_value_expression, 0 },
   4908    false,
   4909    nir_op_ineg,
   4910    { &search24_0_0.value },
   4911    NULL,
   4912 };
   4913 
   4914 #include "compiler/nir/nir_search_helpers.h"
   4915 static const nir_search_variable search24_1 = {
   4916    { nir_search_value_variable, 0 },
   4917    0, /* a */
   4918    false,
   4919    nir_type_invalid,
   4920    NULL,
   4921 };
   4922 #include "compiler/nir/nir_search_helpers.h"
   4923 static const nir_search_expression search24 = {
   4924    { nir_search_value_expression, 0 },
   4925    false,
   4926    nir_op_iadd,
   4927    { &search24_0.value, &search24_1.value },
   4928    NULL,
   4929 };
   4930 
   4931 #include "compiler/nir/nir_search_helpers.h"
   4932 static const nir_search_constant replace24 = {
   4933    { nir_search_value_constant, 0 },
   4934    nir_type_int, { 0x0 /* 0 */ },
   4935 };
   4936 
   4937 #include "compiler/nir/nir_search_helpers.h"
   4938 static const nir_search_variable search25_0_0 = {
   4939    { nir_search_value_variable, 0 },
   4940    0, /* a */
   4941    false,
   4942    nir_type_invalid,
   4943    NULL,
   4944 };
   4945 #include "compiler/nir/nir_search_helpers.h"
   4946 static const nir_search_expression search25_0 = {
   4947    { nir_search_value_expression, 0 },
   4948    false,
   4949    nir_op_ineg,
   4950    { &search25_0_0.value },
   4951    NULL,
   4952 };
   4953 
   4954 #include "compiler/nir/nir_search_helpers.h"
   4955 static const nir_search_variable search25_1_0 = {
   4956    { nir_search_value_variable, 0 },
   4957    0, /* a */
   4958    false,
   4959    nir_type_invalid,
   4960    NULL,
   4961 };
   4962 
   4963 #include "compiler/nir/nir_search_helpers.h"
   4964 static const nir_search_variable search25_1_1 = {
   4965    { nir_search_value_variable, 0 },
   4966    1, /* b */
   4967    false,
   4968    nir_type_invalid,
   4969    NULL,
   4970 };
   4971 #include "compiler/nir/nir_search_helpers.h"
   4972 static const nir_search_expression search25_1 = {
   4973    { nir_search_value_expression, 0 },
   4974    false,
   4975    nir_op_iadd,
   4976    { &search25_1_0.value, &search25_1_1.value },
   4977    NULL,
   4978 };
   4979 #include "compiler/nir/nir_search_helpers.h"
   4980 static const nir_search_expression search25 = {
   4981    { nir_search_value_expression, 0 },
   4982    false,
   4983    nir_op_iadd,
   4984    { &search25_0.value, &search25_1.value },
   4985    NULL,
   4986 };
   4987 
   4988 #include "compiler/nir/nir_search_helpers.h"
   4989 static const nir_search_variable replace25 = {
   4990    { nir_search_value_variable, 0 },
   4991    1, /* b */
   4992    false,
   4993    nir_type_invalid,
   4994    NULL,
   4995 };
   4996 
   4997 #include "compiler/nir/nir_search_helpers.h"
   4998 static const nir_search_variable search26_0 = {
   4999    { nir_search_value_variable, 0 },
   5000    0, /* a */
   5001    false,
   5002    nir_type_invalid,
   5003    NULL,
   5004 };
   5005 
   5006 #include "compiler/nir/nir_search_helpers.h"
   5007 static const nir_search_variable search26_1_0_0 = {
   5008    { nir_search_value_variable, 0 },
   5009    0, /* a */
   5010    false,
   5011    nir_type_invalid,
   5012    NULL,
   5013 };
   5014 #include "compiler/nir/nir_search_helpers.h"
   5015 static const nir_search_expression search26_1_0 = {
   5016    { nir_search_value_expression, 0 },
   5017    false,
   5018    nir_op_ineg,
   5019    { &search26_1_0_0.value },
   5020    NULL,
   5021 };
   5022 
   5023 #include "compiler/nir/nir_search_helpers.h"
   5024 static const nir_search_variable search26_1_1 = {
   5025    { nir_search_value_variable, 0 },
   5026    1, /* b */
   5027    false,
   5028    nir_type_invalid,
   5029    NULL,
   5030 };
   5031 #include "compiler/nir/nir_search_helpers.h"
   5032 static const nir_search_expression search26_1 = {
   5033    { nir_search_value_expression, 0 },
   5034    false,
   5035    nir_op_iadd,
   5036    { &search26_1_0.value, &search26_1_1.value },
   5037    NULL,
   5038 };
   5039 #include "compiler/nir/nir_search_helpers.h"
   5040 static const nir_search_expression search26 = {
   5041    { nir_search_value_expression, 0 },
   5042    false,
   5043    nir_op_iadd,
   5044    { &search26_0.value, &search26_1.value },
   5045    NULL,
   5046 };
   5047 
   5048 #include "compiler/nir/nir_search_helpers.h"
   5049 static const nir_search_variable replace26 = {
   5050    { nir_search_value_variable, 0 },
   5051    1, /* b */
   5052    false,
   5053    nir_type_invalid,
   5054    NULL,
   5055 };
   5056 
   5057 #include "compiler/nir/nir_search_helpers.h"
   5058 static const nir_search_variable search204_0 = {
   5059    { nir_search_value_variable, 0 },
   5060    0, /* a */
   5061    false,
   5062    nir_type_invalid,
   5063    NULL,
   5064 };
   5065 
   5066 #include "compiler/nir/nir_search_helpers.h"
   5067 static const nir_search_constant search204_1_0 = {
   5068    { nir_search_value_constant, 0 },
   5069    nir_type_int, { 0x0 /* 0 */ },
   5070 };
   5071 
   5072 #include "compiler/nir/nir_search_helpers.h"
   5073 static const nir_search_variable search204_1_1 = {
   5074    { nir_search_value_variable, 0 },
   5075    1, /* b */
   5076    false,
   5077    nir_type_invalid,
   5078    NULL,
   5079 };
   5080 #include "compiler/nir/nir_search_helpers.h"
   5081 static const nir_search_expression search204_1 = {
   5082    { nir_search_value_expression, 0 },
   5083    false,
   5084    nir_op_isub,
   5085    { &search204_1_0.value, &search204_1_1.value },
   5086    NULL,
   5087 };
   5088 #include "compiler/nir/nir_search_helpers.h"
   5089 static const nir_search_expression search204 = {
   5090    { nir_search_value_expression, 0 },
   5091    false,
   5092    nir_op_iadd,
   5093    { &search204_0.value, &search204_1.value },
   5094    NULL,
   5095 };
   5096 
   5097 #include "compiler/nir/nir_search_helpers.h"
   5098 static const nir_search_variable replace204_0 = {
   5099    { nir_search_value_variable, 0 },
   5100    0, /* a */
   5101    false,
   5102    nir_type_invalid,
   5103    NULL,
   5104 };
   5105 
   5106 #include "compiler/nir/nir_search_helpers.h"
   5107 static const nir_search_variable replace204_1 = {
   5108    { nir_search_value_variable, 0 },
   5109    1, /* b */
   5110    false,
   5111    nir_type_invalid,
   5112    NULL,
   5113 };
   5114 #include "compiler/nir/nir_search_helpers.h"
   5115 static const nir_search_expression replace204 = {
   5116    { nir_search_value_expression, 0 },
   5117    false,
   5118    nir_op_isub,
   5119    { &replace204_0.value, &replace204_1.value },
   5120    NULL,
   5121 };
   5122 
   5123 #include "compiler/nir/nir_search_helpers.h"
   5124 static const nir_search_variable search212_0 = {
   5125    { nir_search_value_variable, 0 },
   5126    0, /* a */
   5127    true,
   5128    nir_type_invalid,
   5129    NULL,
   5130 };
   5131 
   5132 #include "compiler/nir/nir_search_helpers.h"
   5133 static const nir_search_variable search212_1_0 = {
   5134    { nir_search_value_variable, 0 },
   5135    1, /* b */
   5136    false,
   5137    nir_type_invalid,
   5138    NULL,
   5139 };
   5140 
   5141 #include "compiler/nir/nir_search_helpers.h"
   5142 static const nir_search_variable search212_1_1 = {
   5143    { nir_search_value_variable, 0 },
   5144    2, /* c */
   5145    true,
   5146    nir_type_invalid,
   5147    NULL,
   5148 };
   5149 #include "compiler/nir/nir_search_helpers.h"
   5150 static const nir_search_expression search212_1 = {
   5151    { nir_search_value_expression, 0 },
   5152    false,
   5153    nir_op_iadd,
   5154    { &search212_1_0.value, &search212_1_1.value },
   5155    NULL,
   5156 };
   5157 #include "compiler/nir/nir_search_helpers.h"
   5158 static const nir_search_expression search212 = {
   5159    { nir_search_value_expression, 0 },
   5160    false,
   5161    nir_op_iadd,
   5162    { &search212_0.value, &search212_1.value },
   5163    NULL,
   5164 };
   5165 
   5166 #include "compiler/nir/nir_search_helpers.h"
   5167 static const nir_search_variable replace212_0_0 = {
   5168    { nir_search_value_variable, 0 },
   5169    0, /* a */
   5170    false,
   5171    nir_type_invalid,
   5172    NULL,
   5173 };
   5174 
   5175 #include "compiler/nir/nir_search_helpers.h"
   5176 static const nir_search_variable replace212_0_1 = {
   5177    { nir_search_value_variable, 0 },
   5178    2, /* c */
   5179    false,
   5180    nir_type_invalid,
   5181    NULL,
   5182 };
   5183 #include "compiler/nir/nir_search_helpers.h"
   5184 static const nir_search_expression replace212_0 = {
   5185    { nir_search_value_expression, 0 },
   5186    false,
   5187    nir_op_iadd,
   5188    { &replace212_0_0.value, &replace212_0_1.value },
   5189    NULL,
   5190 };
   5191 
   5192 #include "compiler/nir/nir_search_helpers.h"
   5193 static const nir_search_variable replace212_1 = {
   5194    { nir_search_value_variable, 0 },
   5195    1, /* b */
   5196    false,
   5197    nir_type_invalid,
   5198    NULL,
   5199 };
   5200 #include "compiler/nir/nir_search_helpers.h"
   5201 static const nir_search_expression replace212 = {
   5202    { nir_search_value_expression, 0 },
   5203    false,
   5204    nir_op_iadd,
   5205    { &replace212_0.value, &replace212_1.value },
   5206    NULL,
   5207 };
   5208 
   5209 static const struct transform nir_opt_algebraic_iadd_xforms[] = {
   5210    { &search18, &replace18.value, 0 },
   5211    { &search22, &replace22.value, 0 },
   5212    { &search24, &replace24.value, 0 },
   5213    { &search25, &replace25.value, 0 },
   5214    { &search26, &replace26.value, 0 },
   5215    { &search204, &replace204.value, 0 },
   5216    { &search212, &replace212.value, 0 },
   5217 };
   5218 
   5219 #include "compiler/nir/nir_search_helpers.h"
   5220 static const nir_search_variable search225_0 = {
   5221    { nir_search_value_variable, 0 },
   5222    0, /* v */
   5223    false,
   5224    nir_type_invalid,
   5225    NULL,
   5226 };
   5227 #include "compiler/nir/nir_search_helpers.h"
   5228 static const nir_search_expression search225 = {
   5229    { nir_search_value_expression, 0 },
   5230    false,
   5231    nir_op_pack_unorm_2x16,
   5232    { &search225_0.value },
   5233    NULL,
   5234 };
   5235 
   5236 #include "compiler/nir/nir_search_helpers.h"
   5237 static const nir_search_variable replace225_0_0_0_0_0 = {
   5238    { nir_search_value_variable, 0 },
   5239    0, /* v */
   5240    false,
   5241    nir_type_invalid,
   5242    NULL,
   5243 };
   5244 #include "compiler/nir/nir_search_helpers.h"
   5245 static const nir_search_expression replace225_0_0_0_0 = {
   5246    { nir_search_value_expression, 0 },
   5247    false,
   5248    nir_op_fsat,
   5249    { &replace225_0_0_0_0_0.value },
   5250    NULL,
   5251 };
   5252 
   5253 #include "compiler/nir/nir_search_helpers.h"
   5254 static const nir_search_constant replace225_0_0_0_1 = {
   5255    { nir_search_value_constant, 0 },
   5256    nir_type_float, { 0x40efffe000000000 /* 65535.0 */ },
   5257 };
   5258 #include "compiler/nir/nir_search_helpers.h"
   5259 static const nir_search_expression replace225_0_0_0 = {
   5260    { nir_search_value_expression, 0 },
   5261    false,
   5262    nir_op_fmul,
   5263    { &replace225_0_0_0_0.value, &replace225_0_0_0_1.value },
   5264    NULL,
   5265 };
   5266 #include "compiler/nir/nir_search_helpers.h"
   5267 static const nir_search_expression replace225_0_0 = {
   5268    { nir_search_value_expression, 0 },
   5269    false,
   5270    nir_op_fround_even,
   5271    { &replace225_0_0_0.value },
   5272    NULL,
   5273 };
   5274 #include "compiler/nir/nir_search_helpers.h"
   5275 static const nir_search_expression replace225_0 = {
   5276    { nir_search_value_expression, 0 },
   5277    false,
   5278    nir_op_f2u,
   5279    { &replace225_0_0.value },
   5280    NULL,
   5281 };
   5282 #include "compiler/nir/nir_search_helpers.h"
   5283 static const nir_search_expression replace225 = {
   5284    { nir_search_value_expression, 0 },
   5285    false,
   5286    nir_op_pack_uvec2_to_uint,
   5287    { &replace225_0.value },
   5288    NULL,
   5289 };
   5290 
   5291 static const struct transform nir_opt_algebraic_pack_unorm_2x16_xforms[] = {
   5292    { &search225, &replace225.value, 29 },
   5293 };
   5294 
   5295 #include "compiler/nir/nir_search_helpers.h"
   5296 static const nir_search_variable search226_0 = {
   5297    { nir_search_value_variable, 0 },
   5298    0, /* v */
   5299    false,
   5300    nir_type_invalid,
   5301    NULL,
   5302 };
   5303 #include "compiler/nir/nir_search_helpers.h"
   5304 static const nir_search_expression search226 = {
   5305    { nir_search_value_expression, 0 },
   5306    false,
   5307    nir_op_pack_unorm_4x8,
   5308    { &search226_0.value },
   5309    NULL,
   5310 };
   5311 
   5312 #include "compiler/nir/nir_search_helpers.h"
   5313 static const nir_search_variable replace226_0_0_0_0_0 = {
   5314    { nir_search_value_variable, 0 },
   5315    0, /* v */
   5316    false,
   5317    nir_type_invalid,
   5318    NULL,
   5319 };
   5320 #include "compiler/nir/nir_search_helpers.h"
   5321 static const nir_search_expression replace226_0_0_0_0 = {
   5322    { nir_search_value_expression, 0 },
   5323    false,
   5324    nir_op_fsat,
   5325    { &replace226_0_0_0_0_0.value },
   5326    NULL,
   5327 };
   5328 
   5329 #include "compiler/nir/nir_search_helpers.h"
   5330 static const nir_search_constant replace226_0_0_0_1 = {
   5331    { nir_search_value_constant, 0 },
   5332    nir_type_float, { 0x406fe00000000000 /* 255.0 */ },
   5333 };
   5334 #include "compiler/nir/nir_search_helpers.h"
   5335 static const nir_search_expression replace226_0_0_0 = {
   5336    { nir_search_value_expression, 0 },
   5337    false,
   5338    nir_op_fmul,
   5339    { &replace226_0_0_0_0.value, &replace226_0_0_0_1.value },
   5340    NULL,
   5341 };
   5342 #include "compiler/nir/nir_search_helpers.h"
   5343 static const nir_search_expression replace226_0_0 = {
   5344    { nir_search_value_expression, 0 },
   5345    false,
   5346    nir_op_fround_even,
   5347    { &replace226_0_0_0.value },
   5348    NULL,
   5349 };
   5350 #include "compiler/nir/nir_search_helpers.h"
   5351 static const nir_search_expression replace226_0 = {
   5352    { nir_search_value_expression, 0 },
   5353    false,
   5354    nir_op_f2u,
   5355    { &replace226_0_0.value },
   5356    NULL,
   5357 };
   5358 #include "compiler/nir/nir_search_helpers.h"
   5359 static const nir_search_expression replace226 = {
   5360    { nir_search_value_expression, 0 },
   5361    false,
   5362    nir_op_pack_uvec4_to_uint,
   5363    { &replace226_0.value },
   5364    NULL,
   5365 };
   5366 
   5367 static const struct transform nir_opt_algebraic_pack_unorm_4x8_xforms[] = {
   5368    { &search226, &replace226.value, 30 },
   5369 };
   5370 
   5371 #include "compiler/nir/nir_search_helpers.h"
   5372 static const nir_search_variable search228_0 = {
   5373    { nir_search_value_variable, 0 },
   5374    0, /* v */
   5375    false,
   5376    nir_type_invalid,
   5377    NULL,
   5378 };
   5379 #include "compiler/nir/nir_search_helpers.h"
   5380 static const nir_search_expression search228 = {
   5381    { nir_search_value_expression, 0 },
   5382    false,
   5383    nir_op_pack_snorm_4x8,
   5384    { &search228_0.value },
   5385    NULL,
   5386 };
   5387 
   5388 #include "compiler/nir/nir_search_helpers.h"
   5389 static const nir_search_constant replace228_0_0_0_0_0 = {
   5390    { nir_search_value_constant, 0 },
   5391    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   5392 };
   5393 
   5394 #include "compiler/nir/nir_search_helpers.h"
   5395 static const nir_search_constant replace228_0_0_0_0_1_0 = {
   5396    { nir_search_value_constant, 0 },
   5397    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   5398 };
   5399 
   5400 #include "compiler/nir/nir_search_helpers.h"
   5401 static const nir_search_variable replace228_0_0_0_0_1_1 = {
   5402    { nir_search_value_variable, 0 },
   5403    0, /* v */
   5404    false,
   5405    nir_type_invalid,
   5406    NULL,
   5407 };
   5408 #include "compiler/nir/nir_search_helpers.h"
   5409 static const nir_search_expression replace228_0_0_0_0_1 = {
   5410    { nir_search_value_expression, 0 },
   5411    false,
   5412    nir_op_fmax,
   5413    { &replace228_0_0_0_0_1_0.value, &replace228_0_0_0_0_1_1.value },
   5414    NULL,
   5415 };
   5416 #include "compiler/nir/nir_search_helpers.h"
   5417 static const nir_search_expression replace228_0_0_0_0 = {
   5418    { nir_search_value_expression, 0 },
   5419    false,
   5420    nir_op_fmin,
   5421    { &replace228_0_0_0_0_0.value, &replace228_0_0_0_0_1.value },
   5422    NULL,
   5423 };
   5424 
   5425 #include "compiler/nir/nir_search_helpers.h"
   5426 static const nir_search_constant replace228_0_0_0_1 = {
   5427    { nir_search_value_constant, 0 },
   5428    nir_type_float, { 0x405fc00000000000 /* 127.0 */ },
   5429 };
   5430 #include "compiler/nir/nir_search_helpers.h"
   5431 static const nir_search_expression replace228_0_0_0 = {
   5432    { nir_search_value_expression, 0 },
   5433    false,
   5434    nir_op_fmul,
   5435    { &replace228_0_0_0_0.value, &replace228_0_0_0_1.value },
   5436    NULL,
   5437 };
   5438 #include "compiler/nir/nir_search_helpers.h"
   5439 static const nir_search_expression replace228_0_0 = {
   5440    { nir_search_value_expression, 0 },
   5441    false,
   5442    nir_op_fround_even,
   5443    { &replace228_0_0_0.value },
   5444    NULL,
   5445 };
   5446 #include "compiler/nir/nir_search_helpers.h"
   5447 static const nir_search_expression replace228_0 = {
   5448    { nir_search_value_expression, 0 },
   5449    false,
   5450    nir_op_f2i,
   5451    { &replace228_0_0.value },
   5452    NULL,
   5453 };
   5454 #include "compiler/nir/nir_search_helpers.h"
   5455 static const nir_search_expression replace228 = {
   5456    { nir_search_value_expression, 0 },
   5457    false,
   5458    nir_op_pack_uvec4_to_uint,
   5459    { &replace228_0.value },
   5460    NULL,
   5461 };
   5462 
   5463 static const struct transform nir_opt_algebraic_pack_snorm_4x8_xforms[] = {
   5464    { &search228, &replace228.value, 32 },
   5465 };
   5466 
   5467 #include "compiler/nir/nir_search_helpers.h"
   5468 static const nir_search_variable search121_0 = {
   5469    { nir_search_value_variable, 0 },
   5470    0, /* a */
   5471    false,
   5472    nir_type_invalid,
   5473    NULL,
   5474 };
   5475 
   5476 #include "compiler/nir/nir_search_helpers.h"
   5477 static const nir_search_constant search121_1 = {
   5478    { nir_search_value_constant, 0 },
   5479    nir_type_float, { 0x0 /* 0.0 */ },
   5480 };
   5481 #include "compiler/nir/nir_search_helpers.h"
   5482 static const nir_search_expression search121 = {
   5483    { nir_search_value_expression, 0 },
   5484    false,
   5485    nir_op_fand,
   5486    { &search121_0.value, &search121_1.value },
   5487    NULL,
   5488 };
   5489 
   5490 #include "compiler/nir/nir_search_helpers.h"
   5491 static const nir_search_constant replace121 = {
   5492    { nir_search_value_constant, 0 },
   5493    nir_type_float, { 0x0 /* 0.0 */ },
   5494 };
   5495 
   5496 static const struct transform nir_opt_algebraic_fand_xforms[] = {
   5497    { &search121, &replace121.value, 0 },
   5498 };
   5499 
   5500 #include "compiler/nir/nir_search_helpers.h"
   5501 static const nir_search_variable search12_0_0 = {
   5502    { nir_search_value_variable, 0 },
   5503    0, /* a */
   5504    false,
   5505    nir_type_invalid,
   5506    NULL,
   5507 };
   5508 #include "compiler/nir/nir_search_helpers.h"
   5509 static const nir_search_expression search12_0 = {
   5510    { nir_search_value_expression, 0 },
   5511    false,
   5512    nir_op_fabs,
   5513    { &search12_0_0.value },
   5514    NULL,
   5515 };
   5516 #include "compiler/nir/nir_search_helpers.h"
   5517 static const nir_search_expression search12 = {
   5518    { nir_search_value_expression, 0 },
   5519    false,
   5520    nir_op_fabs,
   5521    { &search12_0.value },
   5522    NULL,
   5523 };
   5524 
   5525 #include "compiler/nir/nir_search_helpers.h"
   5526 static const nir_search_variable replace12_0 = {
   5527    { nir_search_value_variable, 0 },
   5528    0, /* a */
   5529    false,
   5530    nir_type_invalid,
   5531    NULL,
   5532 };
   5533 #include "compiler/nir/nir_search_helpers.h"
   5534 static const nir_search_expression replace12 = {
   5535    { nir_search_value_expression, 0 },
   5536    false,
   5537    nir_op_fabs,
   5538    { &replace12_0.value },
   5539    NULL,
   5540 };
   5541 
   5542 #include "compiler/nir/nir_search_helpers.h"
   5543 static const nir_search_variable search13_0_0 = {
   5544    { nir_search_value_variable, 0 },
   5545    0, /* a */
   5546    false,
   5547    nir_type_invalid,
   5548    NULL,
   5549 };
   5550 #include "compiler/nir/nir_search_helpers.h"
   5551 static const nir_search_expression search13_0 = {
   5552    { nir_search_value_expression, 0 },
   5553    false,
   5554    nir_op_fneg,
   5555    { &search13_0_0.value },
   5556    NULL,
   5557 };
   5558 #include "compiler/nir/nir_search_helpers.h"
   5559 static const nir_search_expression search13 = {
   5560    { nir_search_value_expression, 0 },
   5561    false,
   5562    nir_op_fabs,
   5563    { &search13_0.value },
   5564    NULL,
   5565 };
   5566 
   5567 #include "compiler/nir/nir_search_helpers.h"
   5568 static const nir_search_variable replace13_0 = {
   5569    { nir_search_value_variable, 0 },
   5570    0, /* a */
   5571    false,
   5572    nir_type_invalid,
   5573    NULL,
   5574 };
   5575 #include "compiler/nir/nir_search_helpers.h"
   5576 static const nir_search_expression replace13 = {
   5577    { nir_search_value_expression, 0 },
   5578    false,
   5579    nir_op_fabs,
   5580    { &replace13_0.value },
   5581    NULL,
   5582 };
   5583 
   5584 #include "compiler/nir/nir_search_helpers.h"
   5585 static const nir_search_variable search14_0_0 = {
   5586    { nir_search_value_variable, 0 },
   5587    0, /* a */
   5588    false,
   5589    nir_type_invalid,
   5590    NULL,
   5591 };
   5592 #include "compiler/nir/nir_search_helpers.h"
   5593 static const nir_search_expression search14_0 = {
   5594    { nir_search_value_expression, 0 },
   5595    false,
   5596    nir_op_u2f,
   5597    { &search14_0_0.value },
   5598    NULL,
   5599 };
   5600 #include "compiler/nir/nir_search_helpers.h"
   5601 static const nir_search_expression search14 = {
   5602    { nir_search_value_expression, 0 },
   5603    false,
   5604    nir_op_fabs,
   5605    { &search14_0.value },
   5606    NULL,
   5607 };
   5608 
   5609 #include "compiler/nir/nir_search_helpers.h"
   5610 static const nir_search_variable replace14_0 = {
   5611    { nir_search_value_variable, 0 },
   5612    0, /* a */
   5613    false,
   5614    nir_type_invalid,
   5615    NULL,
   5616 };
   5617 #include "compiler/nir/nir_search_helpers.h"
   5618 static const nir_search_expression replace14 = {
   5619    { nir_search_value_expression, 0 },
   5620    false,
   5621    nir_op_u2f,
   5622    { &replace14_0.value },
   5623    NULL,
   5624 };
   5625 
   5626 #include "compiler/nir/nir_search_helpers.h"
   5627 static const nir_search_variable search98_0_0 = {
   5628    { nir_search_value_variable, 0 },
   5629    0, /* a */
   5630    false,
   5631    nir_type_invalid,
   5632    NULL,
   5633 };
   5634 
   5635 #include "compiler/nir/nir_search_helpers.h"
   5636 static const nir_search_variable search98_0_1 = {
   5637    { nir_search_value_variable, 0 },
   5638    1, /* b */
   5639    false,
   5640    nir_type_invalid,
   5641    NULL,
   5642 };
   5643 #include "compiler/nir/nir_search_helpers.h"
   5644 static const nir_search_expression search98_0 = {
   5645    { nir_search_value_expression, 0 },
   5646    false,
   5647    nir_op_slt,
   5648    { &search98_0_0.value, &search98_0_1.value },
   5649    NULL,
   5650 };
   5651 #include "compiler/nir/nir_search_helpers.h"
   5652 static const nir_search_expression search98 = {
   5653    { nir_search_value_expression, 0 },
   5654    false,
   5655    nir_op_fabs,
   5656    { &search98_0.value },
   5657    NULL,
   5658 };
   5659 
   5660 #include "compiler/nir/nir_search_helpers.h"
   5661 static const nir_search_variable replace98_0 = {
   5662    { nir_search_value_variable, 0 },
   5663    0, /* a */
   5664    false,
   5665    nir_type_invalid,
   5666    NULL,
   5667 };
   5668 
   5669 #include "compiler/nir/nir_search_helpers.h"
   5670 static const nir_search_variable replace98_1 = {
   5671    { nir_search_value_variable, 0 },
   5672    1, /* b */
   5673    false,
   5674    nir_type_invalid,
   5675    NULL,
   5676 };
   5677 #include "compiler/nir/nir_search_helpers.h"
   5678 static const nir_search_expression replace98 = {
   5679    { nir_search_value_expression, 0 },
   5680    false,
   5681    nir_op_slt,
   5682    { &replace98_0.value, &replace98_1.value },
   5683    NULL,
   5684 };
   5685 
   5686 #include "compiler/nir/nir_search_helpers.h"
   5687 static const nir_search_variable search99_0_0 = {
   5688    { nir_search_value_variable, 0 },
   5689    0, /* a */
   5690    false,
   5691    nir_type_invalid,
   5692    NULL,
   5693 };
   5694 
   5695 #include "compiler/nir/nir_search_helpers.h"
   5696 static const nir_search_variable search99_0_1 = {
   5697    { nir_search_value_variable, 0 },
   5698    1, /* b */
   5699    false,
   5700    nir_type_invalid,
   5701    NULL,
   5702 };
   5703 #include "compiler/nir/nir_search_helpers.h"
   5704 static const nir_search_expression search99_0 = {
   5705    { nir_search_value_expression, 0 },
   5706    false,
   5707    nir_op_sge,
   5708    { &search99_0_0.value, &search99_0_1.value },
   5709    NULL,
   5710 };
   5711 #include "compiler/nir/nir_search_helpers.h"
   5712 static const nir_search_expression search99 = {
   5713    { nir_search_value_expression, 0 },
   5714    false,
   5715    nir_op_fabs,
   5716    { &search99_0.value },
   5717    NULL,
   5718 };
   5719 
   5720 #include "compiler/nir/nir_search_helpers.h"
   5721 static const nir_search_variable replace99_0 = {
   5722    { nir_search_value_variable, 0 },
   5723    0, /* a */
   5724    false,
   5725    nir_type_invalid,
   5726    NULL,
   5727 };
   5728 
   5729 #include "compiler/nir/nir_search_helpers.h"
   5730 static const nir_search_variable replace99_1 = {
   5731    { nir_search_value_variable, 0 },
   5732    1, /* b */
   5733    false,
   5734    nir_type_invalid,
   5735    NULL,
   5736 };
   5737 #include "compiler/nir/nir_search_helpers.h"
   5738 static const nir_search_expression replace99 = {
   5739    { nir_search_value_expression, 0 },
   5740    false,
   5741    nir_op_sge,
   5742    { &replace99_0.value, &replace99_1.value },
   5743    NULL,
   5744 };
   5745 
   5746 #include "compiler/nir/nir_search_helpers.h"
   5747 static const nir_search_variable search100_0_0 = {
   5748    { nir_search_value_variable, 0 },
   5749    0, /* a */
   5750    false,
   5751    nir_type_invalid,
   5752    NULL,
   5753 };
   5754 
   5755 #include "compiler/nir/nir_search_helpers.h"
   5756 static const nir_search_variable search100_0_1 = {
   5757    { nir_search_value_variable, 0 },
   5758    1, /* b */
   5759    false,
   5760    nir_type_invalid,
   5761    NULL,
   5762 };
   5763 #include "compiler/nir/nir_search_helpers.h"
   5764 static const nir_search_expression search100_0 = {
   5765    { nir_search_value_expression, 0 },
   5766    false,
   5767    nir_op_seq,
   5768    { &search100_0_0.value, &search100_0_1.value },
   5769    NULL,
   5770 };
   5771 #include "compiler/nir/nir_search_helpers.h"
   5772 static const nir_search_expression search100 = {
   5773    { nir_search_value_expression, 0 },
   5774    false,
   5775    nir_op_fabs,
   5776    { &search100_0.value },
   5777    NULL,
   5778 };
   5779 
   5780 #include "compiler/nir/nir_search_helpers.h"
   5781 static const nir_search_variable replace100_0 = {
   5782    { nir_search_value_variable, 0 },
   5783    0, /* a */
   5784    false,
   5785    nir_type_invalid,
   5786    NULL,
   5787 };
   5788 
   5789 #include "compiler/nir/nir_search_helpers.h"
   5790 static const nir_search_variable replace100_1 = {
   5791    { nir_search_value_variable, 0 },
   5792    1, /* b */
   5793    false,
   5794    nir_type_invalid,
   5795    NULL,
   5796 };
   5797 #include "compiler/nir/nir_search_helpers.h"
   5798 static const nir_search_expression replace100 = {
   5799    { nir_search_value_expression, 0 },
   5800    false,
   5801    nir_op_seq,
   5802    { &replace100_0.value, &replace100_1.value },
   5803    NULL,
   5804 };
   5805 
   5806 #include "compiler/nir/nir_search_helpers.h"
   5807 static const nir_search_variable search101_0_0 = {
   5808    { nir_search_value_variable, 0 },
   5809    0, /* a */
   5810    false,
   5811    nir_type_invalid,
   5812    NULL,
   5813 };
   5814 
   5815 #include "compiler/nir/nir_search_helpers.h"
   5816 static const nir_search_variable search101_0_1 = {
   5817    { nir_search_value_variable, 0 },
   5818    1, /* b */
   5819    false,
   5820    nir_type_invalid,
   5821    NULL,
   5822 };
   5823 #include "compiler/nir/nir_search_helpers.h"
   5824 static const nir_search_expression search101_0 = {
   5825    { nir_search_value_expression, 0 },
   5826    false,
   5827    nir_op_sne,
   5828    { &search101_0_0.value, &search101_0_1.value },
   5829    NULL,
   5830 };
   5831 #include "compiler/nir/nir_search_helpers.h"
   5832 static const nir_search_expression search101 = {
   5833    { nir_search_value_expression, 0 },
   5834    false,
   5835    nir_op_fabs,
   5836    { &search101_0.value },
   5837    NULL,
   5838 };
   5839 
   5840 #include "compiler/nir/nir_search_helpers.h"
   5841 static const nir_search_variable replace101_0 = {
   5842    { nir_search_value_variable, 0 },
   5843    0, /* a */
   5844    false,
   5845    nir_type_invalid,
   5846    NULL,
   5847 };
   5848 
   5849 #include "compiler/nir/nir_search_helpers.h"
   5850 static const nir_search_variable replace101_1 = {
   5851    { nir_search_value_variable, 0 },
   5852    1, /* b */
   5853    false,
   5854    nir_type_invalid,
   5855    NULL,
   5856 };
   5857 #include "compiler/nir/nir_search_helpers.h"
   5858 static const nir_search_expression replace101 = {
   5859    { nir_search_value_expression, 0 },
   5860    false,
   5861    nir_op_sne,
   5862    { &replace101_0.value, &replace101_1.value },
   5863    NULL,
   5864 };
   5865 
   5866 #include "compiler/nir/nir_search_helpers.h"
   5867 static const nir_search_variable search187_0_0 = {
   5868    { nir_search_value_variable, 0 },
   5869    0, /* a */
   5870    false,
   5871    nir_type_invalid,
   5872    NULL,
   5873 };
   5874 #include "compiler/nir/nir_search_helpers.h"
   5875 static const nir_search_expression search187_0 = {
   5876    { nir_search_value_expression, 0 },
   5877    false,
   5878    nir_op_b2f,
   5879    { &search187_0_0.value },
   5880    NULL,
   5881 };
   5882 #include "compiler/nir/nir_search_helpers.h"
   5883 static const nir_search_expression search187 = {
   5884    { nir_search_value_expression, 0 },
   5885    false,
   5886    nir_op_fabs,
   5887    { &search187_0.value },
   5888    NULL,
   5889 };
   5890 
   5891 #include "compiler/nir/nir_search_helpers.h"
   5892 static const nir_search_variable replace187_0 = {
   5893    { nir_search_value_variable, 0 },
   5894    0, /* a */
   5895    false,
   5896    nir_type_invalid,
   5897    NULL,
   5898 };
   5899 #include "compiler/nir/nir_search_helpers.h"
   5900 static const nir_search_expression replace187 = {
   5901    { nir_search_value_expression, 0 },
   5902    false,
   5903    nir_op_b2f,
   5904    { &replace187_0.value },
   5905    NULL,
   5906 };
   5907 
   5908 #include "compiler/nir/nir_search_helpers.h"
   5909 static const nir_search_constant search205_0_0 = {
   5910    { nir_search_value_constant, 0 },
   5911    nir_type_float, { 0x0 /* 0.0 */ },
   5912 };
   5913 
   5914 #include "compiler/nir/nir_search_helpers.h"
   5915 static const nir_search_variable search205_0_1 = {
   5916    { nir_search_value_variable, 0 },
   5917    0, /* a */
   5918    false,
   5919    nir_type_invalid,
   5920    NULL,
   5921 };
   5922 #include "compiler/nir/nir_search_helpers.h"
   5923 static const nir_search_expression search205_0 = {
   5924    { nir_search_value_expression, 0 },
   5925    false,
   5926    nir_op_fsub,
   5927    { &search205_0_0.value, &search205_0_1.value },
   5928    NULL,
   5929 };
   5930 #include "compiler/nir/nir_search_helpers.h"
   5931 static const nir_search_expression search205 = {
   5932    { nir_search_value_expression, 0 },
   5933    false,
   5934    nir_op_fabs,
   5935    { &search205_0.value },
   5936    NULL,
   5937 };
   5938 
   5939 #include "compiler/nir/nir_search_helpers.h"
   5940 static const nir_search_variable replace205_0 = {
   5941    { nir_search_value_variable, 0 },
   5942    0, /* a */
   5943    false,
   5944    nir_type_invalid,
   5945    NULL,
   5946 };
   5947 #include "compiler/nir/nir_search_helpers.h"
   5948 static const nir_search_expression replace205 = {
   5949    { nir_search_value_expression, 0 },
   5950    false,
   5951    nir_op_fabs,
   5952    { &replace205_0.value },
   5953    NULL,
   5954 };
   5955 
   5956 static const struct transform nir_opt_algebraic_fabs_xforms[] = {
   5957    { &search12, &replace12.value, 0 },
   5958    { &search13, &replace13.value, 0 },
   5959    { &search14, &replace14.value, 0 },
   5960    { &search98, &replace98.value, 0 },
   5961    { &search99, &replace99.value, 0 },
   5962    { &search100, &replace100.value, 0 },
   5963    { &search101, &replace101.value, 0 },
   5964    { &search187, &replace187.value, 0 },
   5965    { &search205, &replace205.value, 0 },
   5966 };
   5967 
   5968 #include "compiler/nir/nir_search_helpers.h"
   5969 static const nir_search_variable search5_0 = {
   5970    { nir_search_value_variable, 0 },
   5971    0, /* a */
   5972    false,
   5973    nir_type_invalid,
   5974    NULL,
   5975 };
   5976 
   5977 #include "compiler/nir/nir_search_helpers.h"
   5978 static const nir_search_constant search5_1 = {
   5979    { nir_search_value_constant, 0 },
   5980    nir_type_int, { 0x1 /* 1 */ },
   5981 };
   5982 #include "compiler/nir/nir_search_helpers.h"
   5983 static const nir_search_expression search5 = {
   5984    { nir_search_value_expression, 0 },
   5985    false,
   5986    nir_op_imod,
   5987    { &search5_0.value, &search5_1.value },
   5988    NULL,
   5989 };
   5990 
   5991 #include "compiler/nir/nir_search_helpers.h"
   5992 static const nir_search_constant replace5 = {
   5993    { nir_search_value_constant, 0 },
   5994    nir_type_int, { 0x0 /* 0 */ },
   5995 };
   5996 
   5997 static const struct transform nir_opt_algebraic_imod_xforms[] = {
   5998    { &search5, &replace5.value, 0 },
   5999 };
   6000 
   6001 #include "compiler/nir/nir_search_helpers.h"
   6002 static const nir_search_variable search117_0 = {
   6003    { nir_search_value_variable, 0 },
   6004    0, /* a */
   6005    false,
   6006    nir_type_invalid,
   6007    NULL,
   6008 };
   6009 
   6010 #include "compiler/nir/nir_search_helpers.h"
   6011 static const nir_search_variable search117_1 = {
   6012    { nir_search_value_variable, 0 },
   6013    0, /* a */
   6014    false,
   6015    nir_type_invalid,
   6016    NULL,
   6017 };
   6018 #include "compiler/nir/nir_search_helpers.h"
   6019 static const nir_search_expression search117 = {
   6020    { nir_search_value_expression, 0 },
   6021    false,
   6022    nir_op_ieq,
   6023    { &search117_0.value, &search117_1.value },
   6024    NULL,
   6025 };
   6026 
   6027 #include "compiler/nir/nir_search_helpers.h"
   6028 static const nir_search_constant replace117 = {
   6029    { nir_search_value_constant, 32 },
   6030    nir_type_bool32, { NIR_TRUE /* True */ },
   6031 };
   6032 
   6033 #include "compiler/nir/nir_search_helpers.h"
   6034 static const nir_search_variable search167_0 = {
   6035    { nir_search_value_variable, 32 },
   6036    0, /* a */
   6037    false,
   6038    nir_type_bool32,
   6039    NULL,
   6040 };
   6041 
   6042 #include "compiler/nir/nir_search_helpers.h"
   6043 static const nir_search_constant search167_1 = {
   6044    { nir_search_value_constant, 32 },
   6045    nir_type_bool32, { NIR_TRUE /* True */ },
   6046 };
   6047 #include "compiler/nir/nir_search_helpers.h"
   6048 static const nir_search_expression search167 = {
   6049    { nir_search_value_expression, 0 },
   6050    false,
   6051    nir_op_ieq,
   6052    { &search167_0.value, &search167_1.value },
   6053    NULL,
   6054 };
   6055 
   6056 #include "compiler/nir/nir_search_helpers.h"
   6057 static const nir_search_variable replace167 = {
   6058    { nir_search_value_variable, 0 },
   6059    0, /* a */
   6060    false,
   6061    nir_type_invalid,
   6062    NULL,
   6063 };
   6064 
   6065 #include "compiler/nir/nir_search_helpers.h"
   6066 static const nir_search_variable search170_0 = {
   6067    { nir_search_value_variable, 32 },
   6068    0, /* a */
   6069    false,
   6070    nir_type_bool32,
   6071    NULL,
   6072 };
   6073 
   6074 #include "compiler/nir/nir_search_helpers.h"
   6075 static const nir_search_constant search170_1 = {
   6076    { nir_search_value_constant, 32 },
   6077    nir_type_bool32, { NIR_FALSE /* False */ },
   6078 };
   6079 #include "compiler/nir/nir_search_helpers.h"
   6080 static const nir_search_expression search170 = {
   6081    { nir_search_value_expression, 0 },
   6082    false,
   6083    nir_op_ieq,
   6084    { &search170_0.value, &search170_1.value },
   6085    (is_not_used_by_if),
   6086 };
   6087 
   6088 #include "compiler/nir/nir_search_helpers.h"
   6089 static const nir_search_variable replace170_0 = {
   6090    { nir_search_value_variable, 0 },
   6091    0, /* a */
   6092    false,
   6093    nir_type_invalid,
   6094    NULL,
   6095 };
   6096 #include "compiler/nir/nir_search_helpers.h"
   6097 static const nir_search_expression replace170 = {
   6098    { nir_search_value_expression, 0 },
   6099    false,
   6100    nir_op_inot,
   6101    { &replace170_0.value },
   6102    NULL,
   6103 };
   6104 
   6105 #include "compiler/nir/nir_search_helpers.h"
   6106 static const nir_search_variable search254_0_0 = {
   6107    { nir_search_value_variable, 0 },
   6108    0, /* a */
   6109    false,
   6110    nir_type_invalid,
   6111    NULL,
   6112 };
   6113 
   6114 #include "compiler/nir/nir_search_helpers.h"
   6115 static const nir_search_variable search254_0_1 = {
   6116    { nir_search_value_variable, 0 },
   6117    1, /* b */
   6118    true,
   6119    nir_type_invalid,
   6120    NULL,
   6121 };
   6122 
   6123 #include "compiler/nir/nir_search_helpers.h"
   6124 static const nir_search_variable search254_0_2 = {
   6125    { nir_search_value_variable, 0 },
   6126    2, /* c */
   6127    true,
   6128    nir_type_invalid,
   6129    NULL,
   6130 };
   6131 #include "compiler/nir/nir_search_helpers.h"
   6132 static const nir_search_expression search254_0 = {
   6133    { nir_search_value_expression, 0 },
   6134    false,
   6135    nir_op_bcsel,
   6136    { &search254_0_0.value, &search254_0_1.value, &search254_0_2.value },
   6137    NULL,
   6138 };
   6139 
   6140 #include "compiler/nir/nir_search_helpers.h"
   6141 static const nir_search_variable search254_1 = {
   6142    { nir_search_value_variable, 0 },
   6143    3, /* d */
   6144    true,
   6145    nir_type_invalid,
   6146    NULL,
   6147 };
   6148 #include "compiler/nir/nir_search_helpers.h"
   6149 static const nir_search_expression search254 = {
   6150    { nir_search_value_expression, 0 },
   6151    false,
   6152    nir_op_ieq,
   6153    { &search254_0.value, &search254_1.value },
   6154    NULL,
   6155 };
   6156 
   6157 #include "compiler/nir/nir_search_helpers.h"
   6158 static const nir_search_variable replace254_0 = {
   6159    { nir_search_value_variable, 0 },
   6160    0, /* a */
   6161    false,
   6162    nir_type_invalid,
   6163    NULL,
   6164 };
   6165 
   6166 #include "compiler/nir/nir_search_helpers.h"
   6167 static const nir_search_variable replace254_1_0 = {
   6168    { nir_search_value_variable, 0 },
   6169    1, /* b */
   6170    false,
   6171    nir_type_invalid,
   6172    NULL,
   6173 };
   6174 
   6175 #include "compiler/nir/nir_search_helpers.h"
   6176 static const nir_search_variable replace254_1_1 = {
   6177    { nir_search_value_variable, 0 },
   6178    3, /* d */
   6179    false,
   6180    nir_type_invalid,
   6181    NULL,
   6182 };
   6183 #include "compiler/nir/nir_search_helpers.h"
   6184 static const nir_search_expression replace254_1 = {
   6185    { nir_search_value_expression, 0 },
   6186    false,
   6187    nir_op_ieq,
   6188    { &replace254_1_0.value, &replace254_1_1.value },
   6189    NULL,
   6190 };
   6191 
   6192 #include "compiler/nir/nir_search_helpers.h"
   6193 static const nir_search_variable replace254_2_0 = {
   6194    { nir_search_value_variable, 0 },
   6195    2, /* c */
   6196    false,
   6197    nir_type_invalid,
   6198    NULL,
   6199 };
   6200 
   6201 #include "compiler/nir/nir_search_helpers.h"
   6202 static const nir_search_variable replace254_2_1 = {
   6203    { nir_search_value_variable, 0 },
   6204    3, /* d */
   6205    false,
   6206    nir_type_invalid,
   6207    NULL,
   6208 };
   6209 #include "compiler/nir/nir_search_helpers.h"
   6210 static const nir_search_expression replace254_2 = {
   6211    { nir_search_value_expression, 0 },
   6212    false,
   6213    nir_op_ieq,
   6214    { &replace254_2_0.value, &replace254_2_1.value },
   6215    NULL,
   6216 };
   6217 #include "compiler/nir/nir_search_helpers.h"
   6218 static const nir_search_expression replace254 = {
   6219    { nir_search_value_expression, 0 },
   6220    false,
   6221    nir_op_bcsel,
   6222    { &replace254_0.value, &replace254_1.value, &replace254_2.value },
   6223    NULL,
   6224 };
   6225 
   6226 #include "compiler/nir/nir_search_helpers.h"
   6227 static const nir_search_variable search255_0 = {
   6228    { nir_search_value_variable, 0 },
   6229    0, /* d */
   6230    true,
   6231    nir_type_invalid,
   6232    NULL,
   6233 };
   6234 
   6235 #include "compiler/nir/nir_search_helpers.h"
   6236 static const nir_search_variable search255_1_0 = {
   6237    { nir_search_value_variable, 0 },
   6238    1, /* a */
   6239    false,
   6240    nir_type_invalid,
   6241    NULL,
   6242 };
   6243 
   6244 #include "compiler/nir/nir_search_helpers.h"
   6245 static const nir_search_variable search255_1_1 = {
   6246    { nir_search_value_variable, 0 },
   6247    2, /* b */
   6248    true,
   6249    nir_type_invalid,
   6250    NULL,
   6251 };
   6252 
   6253 #include "compiler/nir/nir_search_helpers.h"
   6254 static const nir_search_variable search255_1_2 = {
   6255    { nir_search_value_variable, 0 },
   6256    3, /* c */
   6257    true,
   6258    nir_type_invalid,
   6259    NULL,
   6260 };
   6261 #include "compiler/nir/nir_search_helpers.h"
   6262 static const nir_search_expression search255_1 = {
   6263    { nir_search_value_expression, 0 },
   6264    false,
   6265    nir_op_bcsel,
   6266    { &search255_1_0.value, &search255_1_1.value, &search255_1_2.value },
   6267    NULL,
   6268 };
   6269 #include "compiler/nir/nir_search_helpers.h"
   6270 static const nir_search_expression search255 = {
   6271    { nir_search_value_expression, 0 },
   6272    false,
   6273    nir_op_ieq,
   6274    { &search255_0.value, &search255_1.value },
   6275    NULL,
   6276 };
   6277 
   6278 #include "compiler/nir/nir_search_helpers.h"
   6279 static const nir_search_variable replace255_0 = {
   6280    { nir_search_value_variable, 0 },
   6281    1, /* a */
   6282    false,
   6283    nir_type_invalid,
   6284    NULL,
   6285 };
   6286 
   6287 #include "compiler/nir/nir_search_helpers.h"
   6288 static const nir_search_variable replace255_1_0 = {
   6289    { nir_search_value_variable, 0 },
   6290    0, /* d */
   6291    false,
   6292    nir_type_invalid,
   6293    NULL,
   6294 };
   6295 
   6296 #include "compiler/nir/nir_search_helpers.h"
   6297 static const nir_search_variable replace255_1_1 = {
   6298    { nir_search_value_variable, 0 },
   6299    2, /* b */
   6300    false,
   6301    nir_type_invalid,
   6302    NULL,
   6303 };
   6304 #include "compiler/nir/nir_search_helpers.h"
   6305 static const nir_search_expression replace255_1 = {
   6306    { nir_search_value_expression, 0 },
   6307    false,
   6308    nir_op_ieq,
   6309    { &replace255_1_0.value, &replace255_1_1.value },
   6310    NULL,
   6311 };
   6312 
   6313 #include "compiler/nir/nir_search_helpers.h"
   6314 static const nir_search_variable replace255_2_0 = {
   6315    { nir_search_value_variable, 0 },
   6316    0, /* d */
   6317    false,
   6318    nir_type_invalid,
   6319    NULL,
   6320 };
   6321 
   6322 #include "compiler/nir/nir_search_helpers.h"
   6323 static const nir_search_variable replace255_2_1 = {
   6324    { nir_search_value_variable, 0 },
   6325    3, /* c */
   6326    false,
   6327    nir_type_invalid,
   6328    NULL,
   6329 };
   6330 #include "compiler/nir/nir_search_helpers.h"
   6331 static const nir_search_expression replace255_2 = {
   6332    { nir_search_value_expression, 0 },
   6333    false,
   6334    nir_op_ieq,
   6335    { &replace255_2_0.value, &replace255_2_1.value },
   6336    NULL,
   6337 };
   6338 #include "compiler/nir/nir_search_helpers.h"
   6339 static const nir_search_expression replace255 = {
   6340    { nir_search_value_expression, 0 },
   6341    false,
   6342    nir_op_bcsel,
   6343    { &replace255_0.value, &replace255_1.value, &replace255_2.value },
   6344    NULL,
   6345 };
   6346 
   6347 static const struct transform nir_opt_algebraic_ieq_xforms[] = {
   6348    { &search117, &replace117.value, 0 },
   6349    { &search167, &replace167.value, 0 },
   6350    { &search170, &replace170.value, 0 },
   6351    { &search254, &replace254.value, 0 },
   6352    { &search255, &replace255.value, 0 },
   6353 };
   6354 
   6355 #include "compiler/nir/nir_search_helpers.h"
   6356 static const nir_search_variable search80_0 = {
   6357    { nir_search_value_variable, 0 },
   6358    0, /* a */
   6359    false,
   6360    nir_type_invalid,
   6361    NULL,
   6362 };
   6363 
   6364 #include "compiler/nir/nir_search_helpers.h"
   6365 static const nir_search_variable search80_1 = {
   6366    { nir_search_value_variable, 0 },
   6367    0, /* a */
   6368    false,
   6369    nir_type_invalid,
   6370    NULL,
   6371 };
   6372 #include "compiler/nir/nir_search_helpers.h"
   6373 static const nir_search_expression search80 = {
   6374    { nir_search_value_expression, 0 },
   6375    false,
   6376    nir_op_imin,
   6377    { &search80_0.value, &search80_1.value },
   6378    NULL,
   6379 };
   6380 
   6381 #include "compiler/nir/nir_search_helpers.h"
   6382 static const nir_search_variable replace80 = {
   6383    { nir_search_value_variable, 0 },
   6384    0, /* a */
   6385    false,
   6386    nir_type_invalid,
   6387    NULL,
   6388 };
   6389 
   6390 #include "compiler/nir/nir_search_helpers.h"
   6391 static const nir_search_variable search89_0_0_0_0 = {
   6392    { nir_search_value_variable, 0 },
   6393    0, /* a */
   6394    false,
   6395    nir_type_invalid,
   6396    NULL,
   6397 };
   6398 
   6399 #include "compiler/nir/nir_search_helpers.h"
   6400 static const nir_search_variable search89_0_0_0_1 = {
   6401    { nir_search_value_variable, 0 },
   6402    1, /* b */
   6403    false,
   6404    nir_type_invalid,
   6405    NULL,
   6406 };
   6407 #include "compiler/nir/nir_search_helpers.h"
   6408 static const nir_search_expression search89_0_0_0 = {
   6409    { nir_search_value_expression, 0 },
   6410    false,
   6411    nir_op_imax,
   6412    { &search89_0_0_0_0.value, &search89_0_0_0_1.value },
   6413    NULL,
   6414 };
   6415 
   6416 #include "compiler/nir/nir_search_helpers.h"
   6417 static const nir_search_variable search89_0_0_1 = {
   6418    { nir_search_value_variable, 0 },
   6419    2, /* c */
   6420    false,
   6421    nir_type_invalid,
   6422    NULL,
   6423 };
   6424 #include "compiler/nir/nir_search_helpers.h"
   6425 static const nir_search_expression search89_0_0 = {
   6426    { nir_search_value_expression, 0 },
   6427    false,
   6428    nir_op_imin,
   6429    { &search89_0_0_0.value, &search89_0_0_1.value },
   6430    NULL,
   6431 };
   6432 
   6433 #include "compiler/nir/nir_search_helpers.h"
   6434 static const nir_search_variable search89_0_1 = {
   6435    { nir_search_value_variable, 0 },
   6436    1, /* b */
   6437    false,
   6438    nir_type_invalid,
   6439    NULL,
   6440 };
   6441 #include "compiler/nir/nir_search_helpers.h"
   6442 static const nir_search_expression search89_0 = {
   6443    { nir_search_value_expression, 0 },
   6444    false,
   6445    nir_op_imax,
   6446    { &search89_0_0.value, &search89_0_1.value },
   6447    NULL,
   6448 };
   6449 
   6450 #include "compiler/nir/nir_search_helpers.h"
   6451 static const nir_search_variable search89_1 = {
   6452    { nir_search_value_variable, 0 },
   6453    2, /* c */
   6454    false,
   6455    nir_type_invalid,
   6456    NULL,
   6457 };
   6458 #include "compiler/nir/nir_search_helpers.h"
   6459 static const nir_search_expression search89 = {
   6460    { nir_search_value_expression, 0 },
   6461    false,
   6462    nir_op_imin,
   6463    { &search89_0.value, &search89_1.value },
   6464    NULL,
   6465 };
   6466 
   6467 #include "compiler/nir/nir_search_helpers.h"
   6468 static const nir_search_variable replace89_0_0 = {
   6469    { nir_search_value_variable, 0 },
   6470    0, /* a */
   6471    false,
   6472    nir_type_invalid,
   6473    NULL,
   6474 };
   6475 
   6476 #include "compiler/nir/nir_search_helpers.h"
   6477 static const nir_search_variable replace89_0_1 = {
   6478    { nir_search_value_variable, 0 },
   6479    1, /* b */
   6480    false,
   6481    nir_type_invalid,
   6482    NULL,
   6483 };
   6484 #include "compiler/nir/nir_search_helpers.h"
   6485 static const nir_search_expression replace89_0 = {
   6486    { nir_search_value_expression, 0 },
   6487    false,
   6488    nir_op_imax,
   6489    { &replace89_0_0.value, &replace89_0_1.value },
   6490    NULL,
   6491 };
   6492 
   6493 #include "compiler/nir/nir_search_helpers.h"
   6494 static const nir_search_variable replace89_1 = {
   6495    { nir_search_value_variable, 0 },
   6496    2, /* c */
   6497    false,
   6498    nir_type_invalid,
   6499    NULL,
   6500 };
   6501 #include "compiler/nir/nir_search_helpers.h"
   6502 static const nir_search_expression replace89 = {
   6503    { nir_search_value_expression, 0 },
   6504    false,
   6505    nir_op_imin,
   6506    { &replace89_0.value, &replace89_1.value },
   6507    NULL,
   6508 };
   6509 
   6510 static const struct transform nir_opt_algebraic_imin_xforms[] = {
   6511    { &search80, &replace80.value, 0 },
   6512    { &search89, &replace89.value, 0 },
   6513 };
   6514 
   6515 #include "compiler/nir/nir_search_helpers.h"
   6516 static const nir_search_variable search155_0_0 = {
   6517    { nir_search_value_variable, 0 },
   6518    0, /* a */
   6519    false,
   6520    nir_type_invalid,
   6521    NULL,
   6522 };
   6523 #include "compiler/nir/nir_search_helpers.h"
   6524 static const nir_search_expression search155_0 = {
   6525    { nir_search_value_expression, 0 },
   6526    false,
   6527    nir_op_fexp2,
   6528    { &search155_0_0.value },
   6529    NULL,
   6530 };
   6531 #include "compiler/nir/nir_search_helpers.h"
   6532 static const nir_search_expression search155 = {
   6533    { nir_search_value_expression, 0 },
   6534    true,
   6535    nir_op_frsq,
   6536    { &search155_0.value },
   6537    NULL,
   6538 };
   6539 
   6540 #include "compiler/nir/nir_search_helpers.h"
   6541 static const nir_search_constant replace155_0_0 = {
   6542    { nir_search_value_constant, 0 },
   6543    nir_type_float, { 0xbfe0000000000000L /* -0.5 */ },
   6544 };
   6545 
   6546 #include "compiler/nir/nir_search_helpers.h"
   6547 static const nir_search_variable replace155_0_1 = {
   6548    { nir_search_value_variable, 0 },
   6549    0, /* a */
   6550    false,
   6551    nir_type_invalid,
   6552    NULL,
   6553 };
   6554 #include "compiler/nir/nir_search_helpers.h"
   6555 static const nir_search_expression replace155_0 = {
   6556    { nir_search_value_expression, 0 },
   6557    false,
   6558    nir_op_fmul,
   6559    { &replace155_0_0.value, &replace155_0_1.value },
   6560    NULL,
   6561 };
   6562 #include "compiler/nir/nir_search_helpers.h"
   6563 static const nir_search_expression replace155 = {
   6564    { nir_search_value_expression, 0 },
   6565    false,
   6566    nir_op_fexp2,
   6567    { &replace155_0.value },
   6568    NULL,
   6569 };
   6570 
   6571 static const struct transform nir_opt_algebraic_frsq_xforms[] = {
   6572    { &search155, &replace155.value, 0 },
   6573 };
   6574 
   6575 #include "compiler/nir/nir_search_helpers.h"
   6576 static const nir_search_variable search19_0 = {
   6577    { nir_search_value_variable, 0 },
   6578    0, /* a */
   6579    false,
   6580    nir_type_invalid,
   6581    NULL,
   6582 };
   6583 
   6584 #include "compiler/nir/nir_search_helpers.h"
   6585 static const nir_search_constant search19_1 = {
   6586    { nir_search_value_constant, 0 },
   6587    nir_type_int, { 0x0 /* 0 */ },
   6588 };
   6589 #include "compiler/nir/nir_search_helpers.h"
   6590 static const nir_search_expression search19 = {
   6591    { nir_search_value_expression, 0 },
   6592    false,
   6593    nir_op_usadd_4x8,
   6594    { &search19_0.value, &search19_1.value },
   6595    NULL,
   6596 };
   6597 
   6598 #include "compiler/nir/nir_search_helpers.h"
   6599 static const nir_search_variable replace19 = {
   6600    { nir_search_value_variable, 0 },
   6601    0, /* a */
   6602    false,
   6603    nir_type_invalid,
   6604    NULL,
   6605 };
   6606 
   6607 #include "compiler/nir/nir_search_helpers.h"
   6608 static const nir_search_variable search20_0 = {
   6609    { nir_search_value_variable, 0 },
   6610    0, /* a */
   6611    false,
   6612    nir_type_invalid,
   6613    NULL,
   6614 };
   6615 
   6616 #include "compiler/nir/nir_search_helpers.h"
   6617 static const nir_search_constant search20_1 = {
   6618    { nir_search_value_constant, 0 },
   6619    nir_type_int, { -0x1 /* -1 */ },
   6620 };
   6621 #include "compiler/nir/nir_search_helpers.h"
   6622 static const nir_search_expression search20 = {
   6623    { nir_search_value_expression, 0 },
   6624    false,
   6625    nir_op_usadd_4x8,
   6626    { &search20_0.value, &search20_1.value },
   6627    NULL,
   6628 };
   6629 
   6630 #include "compiler/nir/nir_search_helpers.h"
   6631 static const nir_search_constant replace20 = {
   6632    { nir_search_value_constant, 0 },
   6633    nir_type_int, { -0x1 /* -1 */ },
   6634 };
   6635 
   6636 static const struct transform nir_opt_algebraic_usadd_4x8_xforms[] = {
   6637    { &search19, &replace19.value, 0 },
   6638    { &search20, &replace20.value, 0 },
   6639 };
   6640 
   6641 #include "compiler/nir/nir_search_helpers.h"
   6642 static const nir_search_variable search3_0 = {
   6643    { nir_search_value_variable, 0 },
   6644    0, /* a */
   6645    false,
   6646    nir_type_invalid,
   6647    NULL,
   6648 };
   6649 
   6650 #include "compiler/nir/nir_search_helpers.h"
   6651 static const nir_search_constant search3_1 = {
   6652    { nir_search_value_constant, 0 },
   6653    nir_type_int, { 0x1 /* 1 */ },
   6654 };
   6655 #include "compiler/nir/nir_search_helpers.h"
   6656 static const nir_search_expression search3 = {
   6657    { nir_search_value_expression, 0 },
   6658    false,
   6659    nir_op_idiv,
   6660    { &search3_0.value, &search3_1.value },
   6661    NULL,
   6662 };
   6663 
   6664 #include "compiler/nir/nir_search_helpers.h"
   6665 static const nir_search_variable replace3 = {
   6666    { nir_search_value_variable, 0 },
   6667    0, /* a */
   6668    false,
   6669    nir_type_invalid,
   6670    NULL,
   6671 };
   6672 
   6673 #include "compiler/nir/nir_search_helpers.h"
   6674 static const nir_search_variable search7_0 = {
   6675    { nir_search_value_variable, 0 },
   6676    0, /* a */
   6677    false,
   6678    nir_type_invalid,
   6679    NULL,
   6680 };
   6681 
   6682 #include "compiler/nir/nir_search_helpers.h"
   6683 static const nir_search_variable search7_1 = {
   6684    { nir_search_value_variable, 32 },
   6685    1, /* b */
   6686    true,
   6687    nir_type_invalid,
   6688    (is_pos_power_of_two),
   6689 };
   6690 #include "compiler/nir/nir_search_helpers.h"
   6691 static const nir_search_expression search7 = {
   6692    { nir_search_value_expression, 0 },
   6693    false,
   6694    nir_op_idiv,
   6695    { &search7_0.value, &search7_1.value },
   6696    NULL,
   6697 };
   6698 
   6699 #include "compiler/nir/nir_search_helpers.h"
   6700 static const nir_search_variable replace7_0_0 = {
   6701    { nir_search_value_variable, 0 },
   6702    0, /* a */
   6703    false,
   6704    nir_type_invalid,
   6705    NULL,
   6706 };
   6707 #include "compiler/nir/nir_search_helpers.h"
   6708 static const nir_search_expression replace7_0 = {
   6709    { nir_search_value_expression, 0 },
   6710    false,
   6711    nir_op_isign,
   6712    { &replace7_0_0.value },
   6713    NULL,
   6714 };
   6715 
   6716 #include "compiler/nir/nir_search_helpers.h"
   6717 static const nir_search_variable replace7_1_0_0 = {
   6718    { nir_search_value_variable, 0 },
   6719    0, /* a */
   6720    false,
   6721    nir_type_invalid,
   6722    NULL,
   6723 };
   6724 #include "compiler/nir/nir_search_helpers.h"
   6725 static const nir_search_expression replace7_1_0 = {
   6726    { nir_search_value_expression, 0 },
   6727    false,
   6728    nir_op_iabs,
   6729    { &replace7_1_0_0.value },
   6730    NULL,
   6731 };
   6732 
   6733 #include "compiler/nir/nir_search_helpers.h"
   6734 static const nir_search_variable replace7_1_1_0 = {
   6735    { nir_search_value_variable, 0 },
   6736    1, /* b */
   6737    false,
   6738    nir_type_invalid,
   6739    NULL,
   6740 };
   6741 #include "compiler/nir/nir_search_helpers.h"
   6742 static const nir_search_expression replace7_1_1 = {
   6743    { nir_search_value_expression, 0 },
   6744    false,
   6745    nir_op_find_lsb,
   6746    { &replace7_1_1_0.value },
   6747    NULL,
   6748 };
   6749 #include "compiler/nir/nir_search_helpers.h"
   6750 static const nir_search_expression replace7_1 = {
   6751    { nir_search_value_expression, 0 },
   6752    false,
   6753    nir_op_ushr,
   6754    { &replace7_1_0.value, &replace7_1_1.value },
   6755    NULL,
   6756 };
   6757 #include "compiler/nir/nir_search_helpers.h"
   6758 static const nir_search_expression replace7 = {
   6759    { nir_search_value_expression, 0 },
   6760    false,
   6761    nir_op_imul,
   6762    { &replace7_0.value, &replace7_1.value },
   6763    NULL,
   6764 };
   6765 
   6766 #include "compiler/nir/nir_search_helpers.h"
   6767 static const nir_search_variable search8_0 = {
   6768    { nir_search_value_variable, 0 },
   6769    0, /* a */
   6770    false,
   6771    nir_type_invalid,
   6772    NULL,
   6773 };
   6774 
   6775 #include "compiler/nir/nir_search_helpers.h"
   6776 static const nir_search_variable search8_1 = {
   6777    { nir_search_value_variable, 32 },
   6778    1, /* b */
   6779    true,
   6780    nir_type_invalid,
   6781    (is_neg_power_of_two),
   6782 };
   6783 #include "compiler/nir/nir_search_helpers.h"
   6784 static const nir_search_expression search8 = {
   6785    { nir_search_value_expression, 0 },
   6786    false,
   6787    nir_op_idiv,
   6788    { &search8_0.value, &search8_1.value },
   6789    NULL,
   6790 };
   6791 
   6792 #include "compiler/nir/nir_search_helpers.h"
   6793 static const nir_search_variable replace8_0_0_0 = {
   6794    { nir_search_value_variable, 0 },
   6795    0, /* a */
   6796    false,
   6797    nir_type_invalid,
   6798    NULL,
   6799 };
   6800 #include "compiler/nir/nir_search_helpers.h"
   6801 static const nir_search_expression replace8_0_0 = {
   6802    { nir_search_value_expression, 0 },
   6803    false,
   6804    nir_op_isign,
   6805    { &replace8_0_0_0.value },
   6806    NULL,
   6807 };
   6808 
   6809 #include "compiler/nir/nir_search_helpers.h"
   6810 static const nir_search_variable replace8_0_1_0_0 = {
   6811    { nir_search_value_variable, 0 },
   6812    0, /* a */
   6813    false,
   6814    nir_type_invalid,
   6815    NULL,
   6816 };
   6817 #include "compiler/nir/nir_search_helpers.h"
   6818 static const nir_search_expression replace8_0_1_0 = {
   6819    { nir_search_value_expression, 0 },
   6820    false,
   6821    nir_op_iabs,
   6822    { &replace8_0_1_0_0.value },
   6823    NULL,
   6824 };
   6825 
   6826 #include "compiler/nir/nir_search_helpers.h"
   6827 static const nir_search_variable replace8_0_1_1_0_0 = {
   6828    { nir_search_value_variable, 0 },
   6829    1, /* b */
   6830    false,
   6831    nir_type_invalid,
   6832    NULL,
   6833 };
   6834 #include "compiler/nir/nir_search_helpers.h"
   6835 static const nir_search_expression replace8_0_1_1_0 = {
   6836    { nir_search_value_expression, 0 },
   6837    false,
   6838    nir_op_iabs,
   6839    { &replace8_0_1_1_0_0.value },
   6840    NULL,
   6841 };
   6842 #include "compiler/nir/nir_search_helpers.h"
   6843 static const nir_search_expression replace8_0_1_1 = {
   6844    { nir_search_value_expression, 0 },
   6845    false,
   6846    nir_op_find_lsb,
   6847    { &replace8_0_1_1_0.value },
   6848    NULL,
   6849 };
   6850 #include "compiler/nir/nir_search_helpers.h"
   6851 static const nir_search_expression replace8_0_1 = {
   6852    { nir_search_value_expression, 0 },
   6853    false,
   6854    nir_op_ushr,
   6855    { &replace8_0_1_0.value, &replace8_0_1_1.value },
   6856    NULL,
   6857 };
   6858 #include "compiler/nir/nir_search_helpers.h"
   6859 static const nir_search_expression replace8_0 = {
   6860    { nir_search_value_expression, 0 },
   6861    false,
   6862    nir_op_imul,
   6863    { &replace8_0_0.value, &replace8_0_1.value },
   6864    NULL,
   6865 };
   6866 #include "compiler/nir/nir_search_helpers.h"
   6867 static const nir_search_expression replace8 = {
   6868    { nir_search_value_expression, 0 },
   6869    false,
   6870    nir_op_ineg,
   6871    { &replace8_0.value },
   6872    NULL,
   6873 };
   6874 
   6875 static const struct transform nir_opt_algebraic_idiv_xforms[] = {
   6876    { &search3, &replace3.value, 0 },
   6877    { &search7, &replace7.value, 1 },
   6878    { &search8, &replace8.value, 1 },
   6879 };
   6880 
   6881 #include "compiler/nir/nir_search_helpers.h"
   6882 static const nir_search_variable search93_0_0_0 = {
   6883    { nir_search_value_variable, 0 },
   6884    0, /* a */
   6885    false,
   6886    nir_type_invalid,
   6887    NULL,
   6888 };
   6889 
   6890 #include "compiler/nir/nir_search_helpers.h"
   6891 static const nir_search_constant search93_0_0_1 = {
   6892    { nir_search_value_constant, 0 },
   6893    nir_type_int, { 0x0 /* 0 */ },
   6894 };
   6895 #include "compiler/nir/nir_search_helpers.h"
   6896 static const nir_search_expression search93_0_0 = {
   6897    { nir_search_value_expression, 0 },
   6898    false,
   6899    nir_op_imax,
   6900    { &search93_0_0_0.value, &search93_0_0_1.value },
   6901    NULL,
   6902 };
   6903 
   6904 #include "compiler/nir/nir_search_helpers.h"
   6905 static const nir_search_constant search93_0_1 = {
   6906    { nir_search_value_constant, 0 },
   6907    nir_type_int, { 0xff /* 255 */ },
   6908 };
   6909 #include "compiler/nir/nir_search_helpers.h"
   6910 static const nir_search_expression search93_0 = {
   6911    { nir_search_value_expression, 0 },
   6912    false,
   6913    nir_op_imin,
   6914    { &search93_0_0.value, &search93_0_1.value },
   6915    NULL,
   6916 };
   6917 
   6918 #include "compiler/nir/nir_search_helpers.h"
   6919 static const nir_search_constant search93_1 = {
   6920    { nir_search_value_constant, 0 },
   6921    nir_type_int, { 0x0 /* 0 */ },
   6922 };
   6923 #include "compiler/nir/nir_search_helpers.h"
   6924 static const nir_search_expression search93 = {
   6925    { nir_search_value_expression, 0 },
   6926    false,
   6927    nir_op_extract_u8,
   6928    { &search93_0.value, &search93_1.value },
   6929    NULL,
   6930 };
   6931 
   6932 #include "compiler/nir/nir_search_helpers.h"
   6933 static const nir_search_variable replace93_0_0 = {
   6934    { nir_search_value_variable, 0 },
   6935    0, /* a */
   6936    false,
   6937    nir_type_invalid,
   6938    NULL,
   6939 };
   6940 
   6941 #include "compiler/nir/nir_search_helpers.h"
   6942 static const nir_search_constant replace93_0_1 = {
   6943    { nir_search_value_constant, 0 },
   6944    nir_type_int, { 0x0 /* 0 */ },
   6945 };
   6946 #include "compiler/nir/nir_search_helpers.h"
   6947 static const nir_search_expression replace93_0 = {
   6948    { nir_search_value_expression, 0 },
   6949    false,
   6950    nir_op_imax,
   6951    { &replace93_0_0.value, &replace93_0_1.value },
   6952    NULL,
   6953 };
   6954 
   6955 #include "compiler/nir/nir_search_helpers.h"
   6956 static const nir_search_constant replace93_1 = {
   6957    { nir_search_value_constant, 0 },
   6958    nir_type_int, { 0xff /* 255 */ },
   6959 };
   6960 #include "compiler/nir/nir_search_helpers.h"
   6961 static const nir_search_expression replace93 = {
   6962    { nir_search_value_expression, 0 },
   6963    false,
   6964    nir_op_imin,
   6965    { &replace93_0.value, &replace93_1.value },
   6966    NULL,
   6967 };
   6968 
   6969 #include "compiler/nir/nir_search_helpers.h"
   6970 static const nir_search_variable search222_0 = {
   6971    { nir_search_value_variable, 0 },
   6972    0, /* a */
   6973    false,
   6974    nir_type_invalid,
   6975    NULL,
   6976 };
   6977 
   6978 #include "compiler/nir/nir_search_helpers.h"
   6979 static const nir_search_variable search222_1 = {
   6980    { nir_search_value_variable, 0 },
   6981    1, /* b */
   6982    false,
   6983    nir_type_invalid,
   6984    NULL,
   6985 };
   6986 #include "compiler/nir/nir_search_helpers.h"
   6987 static const nir_search_expression search222 = {
   6988    { nir_search_value_expression, 0 },
   6989    false,
   6990    nir_op_extract_u8,
   6991    { &search222_0.value, &search222_1.value },
   6992    NULL,
   6993 };
   6994 
   6995 #include "compiler/nir/nir_search_helpers.h"
   6996 static const nir_search_variable replace222_0_0 = {
   6997    { nir_search_value_variable, 0 },
   6998    0, /* a */
   6999    false,
   7000    nir_type_invalid,
   7001    NULL,
   7002 };
   7003 
   7004 #include "compiler/nir/nir_search_helpers.h"
   7005 static const nir_search_variable replace222_0_1_0 = {
   7006    { nir_search_value_variable, 0 },
   7007    1, /* b */
   7008    false,
   7009    nir_type_invalid,
   7010    NULL,
   7011 };
   7012 
   7013 #include "compiler/nir/nir_search_helpers.h"
   7014 static const nir_search_constant replace222_0_1_1 = {
   7015    { nir_search_value_constant, 0 },
   7016    nir_type_int, { 0x8 /* 8 */ },
   7017 };
   7018 #include "compiler/nir/nir_search_helpers.h"
   7019 static const nir_search_expression replace222_0_1 = {
   7020    { nir_search_value_expression, 0 },
   7021    false,
   7022    nir_op_imul,
   7023    { &replace222_0_1_0.value, &replace222_0_1_1.value },
   7024    NULL,
   7025 };
   7026 #include "compiler/nir/nir_search_helpers.h"
   7027 static const nir_search_expression replace222_0 = {
   7028    { nir_search_value_expression, 0 },
   7029    false,
   7030    nir_op_ushr,
   7031    { &replace222_0_0.value, &replace222_0_1.value },
   7032    NULL,
   7033 };
   7034 
   7035 #include "compiler/nir/nir_search_helpers.h"
   7036 static const nir_search_constant replace222_1 = {
   7037    { nir_search_value_constant, 0 },
   7038    nir_type_int, { 0xff /* 255 */ },
   7039 };
   7040 #include "compiler/nir/nir_search_helpers.h"
   7041 static const nir_search_expression replace222 = {
   7042    { nir_search_value_expression, 0 },
   7043    false,
   7044    nir_op_iand,
   7045    { &replace222_0.value, &replace222_1.value },
   7046    NULL,
   7047 };
   7048 
   7049 static const struct transform nir_opt_algebraic_extract_u8_xforms[] = {
   7050    { &search93, &replace93.value, 0 },
   7051    { &search222, &replace222.value, 27 },
   7052 };
   7053 
   7054 #include "compiler/nir/nir_search_helpers.h"
   7055 static const nir_search_variable search227_0 = {
   7056    { nir_search_value_variable, 0 },
   7057    0, /* v */
   7058    false,
   7059    nir_type_invalid,
   7060    NULL,
   7061 };
   7062 #include "compiler/nir/nir_search_helpers.h"
   7063 static const nir_search_expression search227 = {
   7064    { nir_search_value_expression, 0 },
   7065    false,
   7066    nir_op_pack_snorm_2x16,
   7067    { &search227_0.value },
   7068    NULL,
   7069 };
   7070 
   7071 #include "compiler/nir/nir_search_helpers.h"
   7072 static const nir_search_constant replace227_0_0_0_0_0 = {
   7073    { nir_search_value_constant, 0 },
   7074    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   7075 };
   7076 
   7077 #include "compiler/nir/nir_search_helpers.h"
   7078 static const nir_search_constant replace227_0_0_0_0_1_0 = {
   7079    { nir_search_value_constant, 0 },
   7080    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   7081 };
   7082 
   7083 #include "compiler/nir/nir_search_helpers.h"
   7084 static const nir_search_variable replace227_0_0_0_0_1_1 = {
   7085    { nir_search_value_variable, 0 },
   7086    0, /* v */
   7087    false,
   7088    nir_type_invalid,
   7089    NULL,
   7090 };
   7091 #include "compiler/nir/nir_search_helpers.h"
   7092 static const nir_search_expression replace227_0_0_0_0_1 = {
   7093    { nir_search_value_expression, 0 },
   7094    false,
   7095    nir_op_fmax,
   7096    { &replace227_0_0_0_0_1_0.value, &replace227_0_0_0_0_1_1.value },
   7097    NULL,
   7098 };
   7099 #include "compiler/nir/nir_search_helpers.h"
   7100 static const nir_search_expression replace227_0_0_0_0 = {
   7101    { nir_search_value_expression, 0 },
   7102    false,
   7103    nir_op_fmin,
   7104    { &replace227_0_0_0_0_0.value, &replace227_0_0_0_0_1.value },
   7105    NULL,
   7106 };
   7107 
   7108 #include "compiler/nir/nir_search_helpers.h"
   7109 static const nir_search_constant replace227_0_0_0_1 = {
   7110    { nir_search_value_constant, 0 },
   7111    nir_type_float, { 0x40dfffc000000000 /* 32767.0 */ },
   7112 };
   7113 #include "compiler/nir/nir_search_helpers.h"
   7114 static const nir_search_expression replace227_0_0_0 = {
   7115    { nir_search_value_expression, 0 },
   7116    false,
   7117    nir_op_fmul,
   7118    { &replace227_0_0_0_0.value, &replace227_0_0_0_1.value },
   7119    NULL,
   7120 };
   7121 #include "compiler/nir/nir_search_helpers.h"
   7122 static const nir_search_expression replace227_0_0 = {
   7123    { nir_search_value_expression, 0 },
   7124    false,
   7125    nir_op_fround_even,
   7126    { &replace227_0_0_0.value },
   7127    NULL,
   7128 };
   7129 #include "compiler/nir/nir_search_helpers.h"
   7130 static const nir_search_expression replace227_0 = {
   7131    { nir_search_value_expression, 0 },
   7132    false,
   7133    nir_op_f2i,
   7134    { &replace227_0_0.value },
   7135    NULL,
   7136 };
   7137 #include "compiler/nir/nir_search_helpers.h"
   7138 static const nir_search_expression replace227 = {
   7139    { nir_search_value_expression, 0 },
   7140    false,
   7141    nir_op_pack_uvec2_to_uint,
   7142    { &replace227_0.value },
   7143    NULL,
   7144 };
   7145 
   7146 static const struct transform nir_opt_algebraic_pack_snorm_2x16_xforms[] = {
   7147    { &search227, &replace227.value, 31 },
   7148 };
   7149 
   7150 #include "compiler/nir/nir_search_helpers.h"
   7151 static const nir_search_variable search144_0 = {
   7152    { nir_search_value_variable, 0 },
   7153    0, /* a */
   7154    false,
   7155    nir_type_invalid,
   7156    NULL,
   7157 };
   7158 
   7159 #include "compiler/nir/nir_search_helpers.h"
   7160 static const nir_search_variable search144_1 = {
   7161    { nir_search_value_variable, 0 },
   7162    1, /* b */
   7163    false,
   7164    nir_type_invalid,
   7165    NULL,
   7166 };
   7167 #include "compiler/nir/nir_search_helpers.h"
   7168 static const nir_search_expression search144 = {
   7169    { nir_search_value_expression, 0 },
   7170    false,
   7171    nir_op_fpow,
   7172    { &search144_0.value, &search144_1.value },
   7173    NULL,
   7174 };
   7175 
   7176 #include "compiler/nir/nir_search_helpers.h"
   7177 static const nir_search_variable replace144_0_0_0 = {
   7178    { nir_search_value_variable, 0 },
   7179    0, /* a */
   7180    false,
   7181    nir_type_invalid,
   7182    NULL,
   7183 };
   7184 #include "compiler/nir/nir_search_helpers.h"
   7185 static const nir_search_expression replace144_0_0 = {
   7186    { nir_search_value_expression, 0 },
   7187    false,
   7188    nir_op_flog2,
   7189    { &replace144_0_0_0.value },
   7190    NULL,
   7191 };
   7192 
   7193 #include "compiler/nir/nir_search_helpers.h"
   7194 static const nir_search_variable replace144_0_1 = {
   7195    { nir_search_value_variable, 0 },
   7196    1, /* b */
   7197    false,
   7198    nir_type_invalid,
   7199    NULL,
   7200 };
   7201 #include "compiler/nir/nir_search_helpers.h"
   7202 static const nir_search_expression replace144_0 = {
   7203    { nir_search_value_expression, 0 },
   7204    false,
   7205    nir_op_fmul,
   7206    { &replace144_0_0.value, &replace144_0_1.value },
   7207    NULL,
   7208 };
   7209 #include "compiler/nir/nir_search_helpers.h"
   7210 static const nir_search_expression replace144 = {
   7211    { nir_search_value_expression, 0 },
   7212    false,
   7213    nir_op_fexp2,
   7214    { &replace144_0.value },
   7215    NULL,
   7216 };
   7217 
   7218 #include "compiler/nir/nir_search_helpers.h"
   7219 static const nir_search_variable search147_0 = {
   7220    { nir_search_value_variable, 0 },
   7221    0, /* a */
   7222    false,
   7223    nir_type_invalid,
   7224    NULL,
   7225 };
   7226 
   7227 #include "compiler/nir/nir_search_helpers.h"
   7228 static const nir_search_constant search147_1 = {
   7229    { nir_search_value_constant, 0 },
   7230    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   7231 };
   7232 #include "compiler/nir/nir_search_helpers.h"
   7233 static const nir_search_expression search147 = {
   7234    { nir_search_value_expression, 0 },
   7235    true,
   7236    nir_op_fpow,
   7237    { &search147_0.value, &search147_1.value },
   7238    NULL,
   7239 };
   7240 
   7241 #include "compiler/nir/nir_search_helpers.h"
   7242 static const nir_search_variable replace147 = {
   7243    { nir_search_value_variable, 0 },
   7244    0, /* a */
   7245    false,
   7246    nir_type_invalid,
   7247    NULL,
   7248 };
   7249 
   7250 #include "compiler/nir/nir_search_helpers.h"
   7251 static const nir_search_variable search148_0 = {
   7252    { nir_search_value_variable, 0 },
   7253    0, /* a */
   7254    false,
   7255    nir_type_invalid,
   7256    NULL,
   7257 };
   7258 
   7259 #include "compiler/nir/nir_search_helpers.h"
   7260 static const nir_search_constant search148_1 = {
   7261    { nir_search_value_constant, 0 },
   7262    nir_type_float, { 0x4000000000000000 /* 2.0 */ },
   7263 };
   7264 #include "compiler/nir/nir_search_helpers.h"
   7265 static const nir_search_expression search148 = {
   7266    { nir_search_value_expression, 0 },
   7267    true,
   7268    nir_op_fpow,
   7269    { &search148_0.value, &search148_1.value },
   7270    NULL,
   7271 };
   7272 
   7273 #include "compiler/nir/nir_search_helpers.h"
   7274 static const nir_search_variable replace148_0 = {
   7275    { nir_search_value_variable, 0 },
   7276    0, /* a */
   7277    false,
   7278    nir_type_invalid,
   7279    NULL,
   7280 };
   7281 
   7282 #include "compiler/nir/nir_search_helpers.h"
   7283 static const nir_search_variable replace148_1 = {
   7284    { nir_search_value_variable, 0 },
   7285    0, /* a */
   7286    false,
   7287    nir_type_invalid,
   7288    NULL,
   7289 };
   7290 #include "compiler/nir/nir_search_helpers.h"
   7291 static const nir_search_expression replace148 = {
   7292    { nir_search_value_expression, 0 },
   7293    false,
   7294    nir_op_fmul,
   7295    { &replace148_0.value, &replace148_1.value },
   7296    NULL,
   7297 };
   7298 
   7299 #include "compiler/nir/nir_search_helpers.h"
   7300 static const nir_search_variable search149_0 = {
   7301    { nir_search_value_variable, 0 },
   7302    0, /* a */
   7303    false,
   7304    nir_type_invalid,
   7305    NULL,
   7306 };
   7307 
   7308 #include "compiler/nir/nir_search_helpers.h"
   7309 static const nir_search_constant search149_1 = {
   7310    { nir_search_value_constant, 0 },
   7311    nir_type_float, { 0x4010000000000000 /* 4.0 */ },
   7312 };
   7313 #include "compiler/nir/nir_search_helpers.h"
   7314 static const nir_search_expression search149 = {
   7315    { nir_search_value_expression, 0 },
   7316    true,
   7317    nir_op_fpow,
   7318    { &search149_0.value, &search149_1.value },
   7319    NULL,
   7320 };
   7321 
   7322 #include "compiler/nir/nir_search_helpers.h"
   7323 static const nir_search_variable replace149_0_0 = {
   7324    { nir_search_value_variable, 0 },
   7325    0, /* a */
   7326    false,
   7327    nir_type_invalid,
   7328    NULL,
   7329 };
   7330 
   7331 #include "compiler/nir/nir_search_helpers.h"
   7332 static const nir_search_variable replace149_0_1 = {
   7333    { nir_search_value_variable, 0 },
   7334    0, /* a */
   7335    false,
   7336    nir_type_invalid,
   7337    NULL,
   7338 };
   7339 #include "compiler/nir/nir_search_helpers.h"
   7340 static const nir_search_expression replace149_0 = {
   7341    { nir_search_value_expression, 0 },
   7342    false,
   7343    nir_op_fmul,
   7344    { &replace149_0_0.value, &replace149_0_1.value },
   7345    NULL,
   7346 };
   7347 
   7348 #include "compiler/nir/nir_search_helpers.h"
   7349 static const nir_search_variable replace149_1_0 = {
   7350    { nir_search_value_variable, 0 },
   7351    0, /* a */
   7352    false,
   7353    nir_type_invalid,
   7354    NULL,
   7355 };
   7356 
   7357 #include "compiler/nir/nir_search_helpers.h"
   7358 static const nir_search_variable replace149_1_1 = {
   7359    { nir_search_value_variable, 0 },
   7360    0, /* a */
   7361    false,
   7362    nir_type_invalid,
   7363    NULL,
   7364 };
   7365 #include "compiler/nir/nir_search_helpers.h"
   7366 static const nir_search_expression replace149_1 = {
   7367    { nir_search_value_expression, 0 },
   7368    false,
   7369    nir_op_fmul,
   7370    { &replace149_1_0.value, &replace149_1_1.value },
   7371    NULL,
   7372 };
   7373 #include "compiler/nir/nir_search_helpers.h"
   7374 static const nir_search_expression replace149 = {
   7375    { nir_search_value_expression, 0 },
   7376    false,
   7377    nir_op_fmul,
   7378    { &replace149_0.value, &replace149_1.value },
   7379    NULL,
   7380 };
   7381 
   7382 #include "compiler/nir/nir_search_helpers.h"
   7383 static const nir_search_constant search150_0 = {
   7384    { nir_search_value_constant, 0 },
   7385    nir_type_float, { 0x4000000000000000 /* 2.0 */ },
   7386 };
   7387 
   7388 #include "compiler/nir/nir_search_helpers.h"
   7389 static const nir_search_variable search150_1 = {
   7390    { nir_search_value_variable, 0 },
   7391    0, /* a */
   7392    false,
   7393    nir_type_invalid,
   7394    NULL,
   7395 };
   7396 #include "compiler/nir/nir_search_helpers.h"
   7397 static const nir_search_expression search150 = {
   7398    { nir_search_value_expression, 0 },
   7399    true,
   7400    nir_op_fpow,
   7401    { &search150_0.value, &search150_1.value },
   7402    NULL,
   7403 };
   7404 
   7405 #include "compiler/nir/nir_search_helpers.h"
   7406 static const nir_search_variable replace150_0 = {
   7407    { nir_search_value_variable, 0 },
   7408    0, /* a */
   7409    false,
   7410    nir_type_invalid,
   7411    NULL,
   7412 };
   7413 #include "compiler/nir/nir_search_helpers.h"
   7414 static const nir_search_expression replace150 = {
   7415    { nir_search_value_expression, 0 },
   7416    false,
   7417    nir_op_fexp2,
   7418    { &replace150_0.value },
   7419    NULL,
   7420 };
   7421 
   7422 #include "compiler/nir/nir_search_helpers.h"
   7423 static const nir_search_variable search151_0_0 = {
   7424    { nir_search_value_variable, 0 },
   7425    0, /* a */
   7426    false,
   7427    nir_type_invalid,
   7428    NULL,
   7429 };
   7430 
   7431 #include "compiler/nir/nir_search_helpers.h"
   7432 static const nir_search_constant search151_0_1 = {
   7433    { nir_search_value_constant, 0 },
   7434    nir_type_float, { 0x400199999999999a /* 2.2 */ },
   7435 };
   7436 #include "compiler/nir/nir_search_helpers.h"
   7437 static const nir_search_expression search151_0 = {
   7438    { nir_search_value_expression, 0 },
   7439    false,
   7440    nir_op_fpow,
   7441    { &search151_0_0.value, &search151_0_1.value },
   7442    NULL,
   7443 };
   7444 
   7445 #include "compiler/nir/nir_search_helpers.h"
   7446 static const nir_search_constant search151_1 = {
   7447    { nir_search_value_constant, 0 },
   7448    nir_type_float, { 0x3fdd1743e963dc48 /* 0.454545 */ },
   7449 };
   7450 #include "compiler/nir/nir_search_helpers.h"
   7451 static const nir_search_expression search151 = {
   7452    { nir_search_value_expression, 0 },
   7453    true,
   7454    nir_op_fpow,
   7455    { &search151_0.value, &search151_1.value },
   7456    NULL,
   7457 };
   7458 
   7459 #include "compiler/nir/nir_search_helpers.h"
   7460 static const nir_search_variable replace151 = {
   7461    { nir_search_value_variable, 0 },
   7462    0, /* a */
   7463    false,
   7464    nir_type_invalid,
   7465    NULL,
   7466 };
   7467 
   7468 #include "compiler/nir/nir_search_helpers.h"
   7469 static const nir_search_variable search152_0_0_0 = {
   7470    { nir_search_value_variable, 0 },
   7471    0, /* a */
   7472    false,
   7473    nir_type_invalid,
   7474    NULL,
   7475 };
   7476 
   7477 #include "compiler/nir/nir_search_helpers.h"
   7478 static const nir_search_constant search152_0_0_1 = {
   7479    { nir_search_value_constant, 0 },
   7480    nir_type_float, { 0x400199999999999a /* 2.2 */ },
   7481 };
   7482 #include "compiler/nir/nir_search_helpers.h"
   7483 static const nir_search_expression search152_0_0 = {
   7484    { nir_search_value_expression, 0 },
   7485    false,
   7486    nir_op_fpow,
   7487    { &search152_0_0_0.value, &search152_0_0_1.value },
   7488    NULL,
   7489 };
   7490 #include "compiler/nir/nir_search_helpers.h"
   7491 static const nir_search_expression search152_0 = {
   7492    { nir_search_value_expression, 0 },
   7493    false,
   7494    nir_op_fabs,
   7495    { &search152_0_0.value },
   7496    NULL,
   7497 };
   7498 
   7499 #include "compiler/nir/nir_search_helpers.h"
   7500 static const nir_search_constant search152_1 = {
   7501    { nir_search_value_constant, 0 },
   7502    nir_type_float, { 0x3fdd1743e963dc48 /* 0.454545 */ },
   7503 };
   7504 #include "compiler/nir/nir_search_helpers.h"
   7505 static const nir_search_expression search152 = {
   7506    { nir_search_value_expression, 0 },
   7507    true,
   7508    nir_op_fpow,
   7509    { &search152_0.value, &search152_1.value },
   7510    NULL,
   7511 };
   7512 
   7513 #include "compiler/nir/nir_search_helpers.h"
   7514 static const nir_search_variable replace152_0 = {
   7515    { nir_search_value_variable, 0 },
   7516    0, /* a */
   7517    false,
   7518    nir_type_invalid,
   7519    NULL,
   7520 };
   7521 #include "compiler/nir/nir_search_helpers.h"
   7522 static const nir_search_expression replace152 = {
   7523    { nir_search_value_expression, 0 },
   7524    false,
   7525    nir_op_fabs,
   7526    { &replace152_0.value },
   7527    NULL,
   7528 };
   7529 
   7530 static const struct transform nir_opt_algebraic_fpow_xforms[] = {
   7531    { &search144, &replace144.value, 12 },
   7532    { &search147, &replace147.value, 0 },
   7533    { &search148, &replace148.value, 0 },
   7534    { &search149, &replace149.value, 0 },
   7535    { &search150, &replace150.value, 0 },
   7536    { &search151, &replace151.value, 0 },
   7537    { &search152, &replace152.value, 0 },
   7538 };
   7539 
   7540 #include "compiler/nir/nir_search_helpers.h"
   7541 static const nir_search_variable search116_0 = {
   7542    { nir_search_value_variable, 0 },
   7543    0, /* a */
   7544    false,
   7545    nir_type_invalid,
   7546    NULL,
   7547 };
   7548 
   7549 #include "compiler/nir/nir_search_helpers.h"
   7550 static const nir_search_variable search116_1 = {
   7551    { nir_search_value_variable, 0 },
   7552    0, /* a */
   7553    false,
   7554    nir_type_invalid,
   7555    NULL,
   7556 };
   7557 #include "compiler/nir/nir_search_helpers.h"
   7558 static const nir_search_expression search116 = {
   7559    { nir_search_value_expression, 0 },
   7560    false,
   7561    nir_op_ige,
   7562    { &search116_0.value, &search116_1.value },
   7563    NULL,
   7564 };
   7565 
   7566 #include "compiler/nir/nir_search_helpers.h"
   7567 static const nir_search_constant replace116 = {
   7568    { nir_search_value_constant, 32 },
   7569    nir_type_bool32, { NIR_TRUE /* True */ },
   7570 };
   7571 
   7572 #include "compiler/nir/nir_search_helpers.h"
   7573 static const nir_search_variable search252_0_0 = {
   7574    { nir_search_value_variable, 0 },
   7575    0, /* a */
   7576    false,
   7577    nir_type_invalid,
   7578    NULL,
   7579 };
   7580 
   7581 #include "compiler/nir/nir_search_helpers.h"
   7582 static const nir_search_variable search252_0_1 = {
   7583    { nir_search_value_variable, 0 },
   7584    1, /* b */
   7585    true,
   7586    nir_type_invalid,
   7587    NULL,
   7588 };
   7589 
   7590 #include "compiler/nir/nir_search_helpers.h"
   7591 static const nir_search_variable search252_0_2 = {
   7592    { nir_search_value_variable, 0 },
   7593    2, /* c */
   7594    true,
   7595    nir_type_invalid,
   7596    NULL,
   7597 };
   7598 #include "compiler/nir/nir_search_helpers.h"
   7599 static const nir_search_expression search252_0 = {
   7600    { nir_search_value_expression, 0 },
   7601    false,
   7602    nir_op_bcsel,
   7603    { &search252_0_0.value, &search252_0_1.value, &search252_0_2.value },
   7604    NULL,
   7605 };
   7606 
   7607 #include "compiler/nir/nir_search_helpers.h"
   7608 static const nir_search_variable search252_1 = {
   7609    { nir_search_value_variable, 0 },
   7610    3, /* d */
   7611    true,
   7612    nir_type_invalid,
   7613    NULL,
   7614 };
   7615 #include "compiler/nir/nir_search_helpers.h"
   7616 static const nir_search_expression search252 = {
   7617    { nir_search_value_expression, 0 },
   7618    false,
   7619    nir_op_ige,
   7620    { &search252_0.value, &search252_1.value },
   7621    NULL,
   7622 };
   7623 
   7624 #include "compiler/nir/nir_search_helpers.h"
   7625 static const nir_search_variable replace252_0 = {
   7626    { nir_search_value_variable, 0 },
   7627    0, /* a */
   7628    false,
   7629    nir_type_invalid,
   7630    NULL,
   7631 };
   7632 
   7633 #include "compiler/nir/nir_search_helpers.h"
   7634 static const nir_search_variable replace252_1_0 = {
   7635    { nir_search_value_variable, 0 },
   7636    1, /* b */
   7637    false,
   7638    nir_type_invalid,
   7639    NULL,
   7640 };
   7641 
   7642 #include "compiler/nir/nir_search_helpers.h"
   7643 static const nir_search_variable replace252_1_1 = {
   7644    { nir_search_value_variable, 0 },
   7645    3, /* d */
   7646    false,
   7647    nir_type_invalid,
   7648    NULL,
   7649 };
   7650 #include "compiler/nir/nir_search_helpers.h"
   7651 static const nir_search_expression replace252_1 = {
   7652    { nir_search_value_expression, 0 },
   7653    false,
   7654    nir_op_ige,
   7655    { &replace252_1_0.value, &replace252_1_1.value },
   7656    NULL,
   7657 };
   7658 
   7659 #include "compiler/nir/nir_search_helpers.h"
   7660 static const nir_search_variable replace252_2_0 = {
   7661    { nir_search_value_variable, 0 },
   7662    2, /* c */
   7663    false,
   7664    nir_type_invalid,
   7665    NULL,
   7666 };
   7667 
   7668 #include "compiler/nir/nir_search_helpers.h"
   7669 static const nir_search_variable replace252_2_1 = {
   7670    { nir_search_value_variable, 0 },
   7671    3, /* d */
   7672    false,
   7673    nir_type_invalid,
   7674    NULL,
   7675 };
   7676 #include "compiler/nir/nir_search_helpers.h"
   7677 static const nir_search_expression replace252_2 = {
   7678    { nir_search_value_expression, 0 },
   7679    false,
   7680    nir_op_ige,
   7681    { &replace252_2_0.value, &replace252_2_1.value },
   7682    NULL,
   7683 };
   7684 #include "compiler/nir/nir_search_helpers.h"
   7685 static const nir_search_expression replace252 = {
   7686    { nir_search_value_expression, 0 },
   7687    false,
   7688    nir_op_bcsel,
   7689    { &replace252_0.value, &replace252_1.value, &replace252_2.value },
   7690    NULL,
   7691 };
   7692 
   7693 #include "compiler/nir/nir_search_helpers.h"
   7694 static const nir_search_variable search253_0 = {
   7695    { nir_search_value_variable, 0 },
   7696    0, /* d */
   7697    true,
   7698    nir_type_invalid,
   7699    NULL,
   7700 };
   7701 
   7702 #include "compiler/nir/nir_search_helpers.h"
   7703 static const nir_search_variable search253_1_0 = {
   7704    { nir_search_value_variable, 0 },
   7705    1, /* a */
   7706    false,
   7707    nir_type_invalid,
   7708    NULL,
   7709 };
   7710 
   7711 #include "compiler/nir/nir_search_helpers.h"
   7712 static const nir_search_variable search253_1_1 = {
   7713    { nir_search_value_variable, 0 },
   7714    2, /* b */
   7715    true,
   7716    nir_type_invalid,
   7717    NULL,
   7718 };
   7719 
   7720 #include "compiler/nir/nir_search_helpers.h"
   7721 static const nir_search_variable search253_1_2 = {
   7722    { nir_search_value_variable, 0 },
   7723    3, /* c */
   7724    true,
   7725    nir_type_invalid,
   7726    NULL,
   7727 };
   7728 #include "compiler/nir/nir_search_helpers.h"
   7729 static const nir_search_expression search253_1 = {
   7730    { nir_search_value_expression, 0 },
   7731    false,
   7732    nir_op_bcsel,
   7733    { &search253_1_0.value, &search253_1_1.value, &search253_1_2.value },
   7734    NULL,
   7735 };
   7736 #include "compiler/nir/nir_search_helpers.h"
   7737 static const nir_search_expression search253 = {
   7738    { nir_search_value_expression, 0 },
   7739    false,
   7740    nir_op_ige,
   7741    { &search253_0.value, &search253_1.value },
   7742    NULL,
   7743 };
   7744 
   7745 #include "compiler/nir/nir_search_helpers.h"
   7746 static const nir_search_variable replace253_0 = {
   7747    { nir_search_value_variable, 0 },
   7748    1, /* a */
   7749    false,
   7750    nir_type_invalid,
   7751    NULL,
   7752 };
   7753 
   7754 #include "compiler/nir/nir_search_helpers.h"
   7755 static const nir_search_variable replace253_1_0 = {
   7756    { nir_search_value_variable, 0 },
   7757    0, /* d */
   7758    false,
   7759    nir_type_invalid,
   7760    NULL,
   7761 };
   7762 
   7763 #include "compiler/nir/nir_search_helpers.h"
   7764 static const nir_search_variable replace253_1_1 = {
   7765    { nir_search_value_variable, 0 },
   7766    2, /* b */
   7767    false,
   7768    nir_type_invalid,
   7769    NULL,
   7770 };
   7771 #include "compiler/nir/nir_search_helpers.h"
   7772 static const nir_search_expression replace253_1 = {
   7773    { nir_search_value_expression, 0 },
   7774    false,
   7775    nir_op_ige,
   7776    { &replace253_1_0.value, &replace253_1_1.value },
   7777    NULL,
   7778 };
   7779 
   7780 #include "compiler/nir/nir_search_helpers.h"
   7781 static const nir_search_variable replace253_2_0 = {
   7782    { nir_search_value_variable, 0 },
   7783    0, /* d */
   7784    false,
   7785    nir_type_invalid,
   7786    NULL,
   7787 };
   7788 
   7789 #include "compiler/nir/nir_search_helpers.h"
   7790 static const nir_search_variable replace253_2_1 = {
   7791    { nir_search_value_variable, 0 },
   7792    3, /* c */
   7793    false,
   7794    nir_type_invalid,
   7795    NULL,
   7796 };
   7797 #include "compiler/nir/nir_search_helpers.h"
   7798 static const nir_search_expression replace253_2 = {
   7799    { nir_search_value_expression, 0 },
   7800    false,
   7801    nir_op_ige,
   7802    { &replace253_2_0.value, &replace253_2_1.value },
   7803    NULL,
   7804 };
   7805 #include "compiler/nir/nir_search_helpers.h"
   7806 static const nir_search_expression replace253 = {
   7807    { nir_search_value_expression, 0 },
   7808    false,
   7809    nir_op_bcsel,
   7810    { &replace253_0.value, &replace253_1.value, &replace253_2.value },
   7811    NULL,
   7812 };
   7813 
   7814 static const struct transform nir_opt_algebraic_ige_xforms[] = {
   7815    { &search116, &replace116.value, 0 },
   7816    { &search252, &replace252.value, 0 },
   7817    { &search253, &replace253.value, 0 },
   7818 };
   7819 
   7820 #include "compiler/nir/nir_search_helpers.h"
   7821 static const nir_search_constant search161_0 = {
   7822    { nir_search_value_constant, 0 },
   7823    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   7824 };
   7825 
   7826 #include "compiler/nir/nir_search_helpers.h"
   7827 static const nir_search_variable search161_1 = {
   7828    { nir_search_value_variable, 0 },
   7829    0, /* a */
   7830    false,
   7831    nir_type_invalid,
   7832    NULL,
   7833 };
   7834 #include "compiler/nir/nir_search_helpers.h"
   7835 static const nir_search_expression search161 = {
   7836    { nir_search_value_expression, 0 },
   7837    true,
   7838    nir_op_fdiv,
   7839    { &search161_0.value, &search161_1.value },
   7840    NULL,
   7841 };
   7842 
   7843 #include "compiler/nir/nir_search_helpers.h"
   7844 static const nir_search_variable replace161_0 = {
   7845    { nir_search_value_variable, 0 },
   7846    0, /* a */
   7847    false,
   7848    nir_type_invalid,
   7849    NULL,
   7850 };
   7851 #include "compiler/nir/nir_search_helpers.h"
   7852 static const nir_search_expression replace161 = {
   7853    { nir_search_value_expression, 0 },
   7854    false,
   7855    nir_op_frcp,
   7856    { &replace161_0.value },
   7857    NULL,
   7858 };
   7859 
   7860 #include "compiler/nir/nir_search_helpers.h"
   7861 static const nir_search_variable search162_0 = {
   7862    { nir_search_value_variable, 0 },
   7863    0, /* a */
   7864    false,
   7865    nir_type_invalid,
   7866    NULL,
   7867 };
   7868 
   7869 #include "compiler/nir/nir_search_helpers.h"
   7870 static const nir_search_variable search162_1 = {
   7871    { nir_search_value_variable, 0 },
   7872    1, /* b */
   7873    false,
   7874    nir_type_invalid,
   7875    NULL,
   7876 };
   7877 #include "compiler/nir/nir_search_helpers.h"
   7878 static const nir_search_expression search162 = {
   7879    { nir_search_value_expression, 0 },
   7880    false,
   7881    nir_op_fdiv,
   7882    { &search162_0.value, &search162_1.value },
   7883    NULL,
   7884 };
   7885 
   7886 #include "compiler/nir/nir_search_helpers.h"
   7887 static const nir_search_variable replace162_0 = {
   7888    { nir_search_value_variable, 0 },
   7889    0, /* a */
   7890    false,
   7891    nir_type_invalid,
   7892    NULL,
   7893 };
   7894 
   7895 #include "compiler/nir/nir_search_helpers.h"
   7896 static const nir_search_variable replace162_1_0 = {
   7897    { nir_search_value_variable, 0 },
   7898    1, /* b */
   7899    false,
   7900    nir_type_invalid,
   7901    NULL,
   7902 };
   7903 #include "compiler/nir/nir_search_helpers.h"
   7904 static const nir_search_expression replace162_1 = {
   7905    { nir_search_value_expression, 0 },
   7906    false,
   7907    nir_op_frcp,
   7908    { &replace162_1_0.value },
   7909    NULL,
   7910 };
   7911 #include "compiler/nir/nir_search_helpers.h"
   7912 static const nir_search_expression replace162 = {
   7913    { nir_search_value_expression, 0 },
   7914    false,
   7915    nir_op_fmul,
   7916    { &replace162_0.value, &replace162_1.value },
   7917    NULL,
   7918 };
   7919 
   7920 static const struct transform nir_opt_algebraic_fdiv_xforms[] = {
   7921    { &search161, &replace161.value, 0 },
   7922    { &search162, &replace162.value, 14 },
   7923 };
   7924 
   7925 #include "compiler/nir/nir_search_helpers.h"
   7926 static const nir_search_variable search50_0 = {
   7927    { nir_search_value_variable, 0 },
   7928    0, /* a */
   7929    false,
   7930    nir_type_invalid,
   7931    NULL,
   7932 };
   7933 #include "compiler/nir/nir_search_helpers.h"
   7934 static const nir_search_expression search50 = {
   7935    { nir_search_value_expression, 0 },
   7936    false,
   7937    nir_op_ffract,
   7938    { &search50_0.value },
   7939    NULL,
   7940 };
   7941 
   7942 #include "compiler/nir/nir_search_helpers.h"
   7943 static const nir_search_variable replace50_0 = {
   7944    { nir_search_value_variable, 0 },
   7945    0, /* a */
   7946    false,
   7947    nir_type_invalid,
   7948    NULL,
   7949 };
   7950 
   7951 #include "compiler/nir/nir_search_helpers.h"
   7952 static const nir_search_variable replace50_1_0 = {
   7953    { nir_search_value_variable, 0 },
   7954    0, /* a */
   7955    false,
   7956    nir_type_invalid,
   7957    NULL,
   7958 };
   7959 #include "compiler/nir/nir_search_helpers.h"
   7960 static const nir_search_expression replace50_1 = {
   7961    { nir_search_value_expression, 0 },
   7962    false,
   7963    nir_op_ffloor,
   7964    { &replace50_1_0.value },
   7965    NULL,
   7966 };
   7967 #include "compiler/nir/nir_search_helpers.h"
   7968 static const nir_search_expression replace50 = {
   7969    { nir_search_value_expression, 0 },
   7970    false,
   7971    nir_op_fsub,
   7972    { &replace50_0.value, &replace50_1.value },
   7973    NULL,
   7974 };
   7975 
   7976 static const struct transform nir_opt_algebraic_ffract_xforms[] = {
   7977    { &search50, &replace50.value, 4 },
   7978 };
   7979 
   7980 #include "compiler/nir/nir_search_helpers.h"
   7981 static const nir_search_variable search17_0 = {
   7982    { nir_search_value_variable, 0 },
   7983    0, /* a */
   7984    false,
   7985    nir_type_invalid,
   7986    NULL,
   7987 };
   7988 
   7989 #include "compiler/nir/nir_search_helpers.h"
   7990 static const nir_search_constant search17_1 = {
   7991    { nir_search_value_constant, 0 },
   7992    nir_type_float, { 0x0 /* 0.0 */ },
   7993 };
   7994 #include "compiler/nir/nir_search_helpers.h"
   7995 static const nir_search_expression search17 = {
   7996    { nir_search_value_expression, 0 },
   7997    true,
   7998    nir_op_fadd,
   7999    { &search17_0.value, &search17_1.value },
   8000    NULL,
   8001 };
   8002 
   8003 #include "compiler/nir/nir_search_helpers.h"
   8004 static const nir_search_variable replace17 = {
   8005    { nir_search_value_variable, 0 },
   8006    0, /* a */
   8007    false,
   8008    nir_type_invalid,
   8009    NULL,
   8010 };
   8011 
   8012 #include "compiler/nir/nir_search_helpers.h"
   8013 static const nir_search_variable search21_0_0 = {
   8014    { nir_search_value_variable, 0 },
   8015    0, /* a */
   8016    false,
   8017    nir_type_invalid,
   8018    NULL,
   8019 };
   8020 
   8021 #include "compiler/nir/nir_search_helpers.h"
   8022 static const nir_search_variable search21_0_1 = {
   8023    { nir_search_value_variable, 0 },
   8024    1, /* b */
   8025    false,
   8026    nir_type_invalid,
   8027    NULL,
   8028 };
   8029 #include "compiler/nir/nir_search_helpers.h"
   8030 static const nir_search_expression search21_0 = {
   8031    { nir_search_value_expression, 0 },
   8032    false,
   8033    nir_op_fmul,
   8034    { &search21_0_0.value, &search21_0_1.value },
   8035    NULL,
   8036 };
   8037 
   8038 #include "compiler/nir/nir_search_helpers.h"
   8039 static const nir_search_variable search21_1_0 = {
   8040    { nir_search_value_variable, 0 },
   8041    0, /* a */
   8042    false,
   8043    nir_type_invalid,
   8044    NULL,
   8045 };
   8046 
   8047 #include "compiler/nir/nir_search_helpers.h"
   8048 static const nir_search_variable search21_1_1 = {
   8049    { nir_search_value_variable, 0 },
   8050    2, /* c */
   8051    false,
   8052    nir_type_invalid,
   8053    NULL,
   8054 };
   8055 #include "compiler/nir/nir_search_helpers.h"
   8056 static const nir_search_expression search21_1 = {
   8057    { nir_search_value_expression, 0 },
   8058    false,
   8059    nir_op_fmul,
   8060    { &search21_1_0.value, &search21_1_1.value },
   8061    NULL,
   8062 };
   8063 #include "compiler/nir/nir_search_helpers.h"
   8064 static const nir_search_expression search21 = {
   8065    { nir_search_value_expression, 0 },
   8066    true,
   8067    nir_op_fadd,
   8068    { &search21_0.value, &search21_1.value },
   8069    NULL,
   8070 };
   8071 
   8072 #include "compiler/nir/nir_search_helpers.h"
   8073 static const nir_search_variable replace21_0 = {
   8074    { nir_search_value_variable, 0 },
   8075    0, /* a */
   8076    false,
   8077    nir_type_invalid,
   8078    NULL,
   8079 };
   8080 
   8081 #include "compiler/nir/nir_search_helpers.h"
   8082 static const nir_search_variable replace21_1_0 = {
   8083    { nir_search_value_variable, 0 },
   8084    1, /* b */
   8085    false,
   8086    nir_type_invalid,
   8087    NULL,
   8088 };
   8089 
   8090 #include "compiler/nir/nir_search_helpers.h"
   8091 static const nir_search_variable replace21_1_1 = {
   8092    { nir_search_value_variable, 0 },
   8093    2, /* c */
   8094    false,
   8095    nir_type_invalid,
   8096    NULL,
   8097 };
   8098 #include "compiler/nir/nir_search_helpers.h"
   8099 static const nir_search_expression replace21_1 = {
   8100    { nir_search_value_expression, 0 },
   8101    false,
   8102    nir_op_fadd,
   8103    { &replace21_1_0.value, &replace21_1_1.value },
   8104    NULL,
   8105 };
   8106 #include "compiler/nir/nir_search_helpers.h"
   8107 static const nir_search_expression replace21 = {
   8108    { nir_search_value_expression, 0 },
   8109    false,
   8110    nir_op_fmul,
   8111    { &replace21_0.value, &replace21_1.value },
   8112    NULL,
   8113 };
   8114 
   8115 #include "compiler/nir/nir_search_helpers.h"
   8116 static const nir_search_variable search23_0_0 = {
   8117    { nir_search_value_variable, 0 },
   8118    0, /* a */
   8119    false,
   8120    nir_type_invalid,
   8121    NULL,
   8122 };
   8123 #include "compiler/nir/nir_search_helpers.h"
   8124 static const nir_search_expression search23_0 = {
   8125    { nir_search_value_expression, 0 },
   8126    false,
   8127    nir_op_fneg,
   8128    { &search23_0_0.value },
   8129    NULL,
   8130 };
   8131 
   8132 #include "compiler/nir/nir_search_helpers.h"
   8133 static const nir_search_variable search23_1 = {
   8134    { nir_search_value_variable, 0 },
   8135    0, /* a */
   8136    false,
   8137    nir_type_invalid,
   8138    NULL,
   8139 };
   8140 #include "compiler/nir/nir_search_helpers.h"
   8141 static const nir_search_expression search23 = {
   8142    { nir_search_value_expression, 0 },
   8143    true,
   8144    nir_op_fadd,
   8145    { &search23_0.value, &search23_1.value },
   8146    NULL,
   8147 };
   8148 
   8149 #include "compiler/nir/nir_search_helpers.h"
   8150 static const nir_search_constant replace23 = {
   8151    { nir_search_value_constant, 0 },
   8152    nir_type_float, { 0x0 /* 0.0 */ },
   8153 };
   8154 
   8155 #include "compiler/nir/nir_search_helpers.h"
   8156 static const nir_search_variable search27_0_0 = {
   8157    { nir_search_value_variable, 0 },
   8158    0, /* a */
   8159    false,
   8160    nir_type_invalid,
   8161    NULL,
   8162 };
   8163 #include "compiler/nir/nir_search_helpers.h"
   8164 static const nir_search_expression search27_0 = {
   8165    { nir_search_value_expression, 0 },
   8166    false,
   8167    nir_op_fneg,
   8168    { &search27_0_0.value },
   8169    NULL,
   8170 };
   8171 
   8172 #include "compiler/nir/nir_search_helpers.h"
   8173 static const nir_search_variable search27_1_0 = {
   8174    { nir_search_value_variable, 0 },
   8175    0, /* a */
   8176    false,
   8177    nir_type_invalid,
   8178    NULL,
   8179 };
   8180 
   8181 #include "compiler/nir/nir_search_helpers.h"
   8182 static const nir_search_variable search27_1_1 = {
   8183    { nir_search_value_variable, 0 },
   8184    1, /* b */
   8185    false,
   8186    nir_type_invalid,
   8187    NULL,
   8188 };
   8189 #include "compiler/nir/nir_search_helpers.h"
   8190 static const nir_search_expression search27_1 = {
   8191    { nir_search_value_expression, 0 },
   8192    false,
   8193    nir_op_fadd,
   8194    { &search27_1_0.value, &search27_1_1.value },
   8195    NULL,
   8196 };
   8197 #include "compiler/nir/nir_search_helpers.h"
   8198 static const nir_search_expression search27 = {
   8199    { nir_search_value_expression, 0 },
   8200    true,
   8201    nir_op_fadd,
   8202    { &search27_0.value, &search27_1.value },
   8203    NULL,
   8204 };
   8205 
   8206 #include "compiler/nir/nir_search_helpers.h"
   8207 static const nir_search_variable replace27 = {
   8208    { nir_search_value_variable, 0 },
   8209    1, /* b */
   8210    false,
   8211    nir_type_invalid,
   8212    NULL,
   8213 };
   8214 
   8215 #include "compiler/nir/nir_search_helpers.h"
   8216 static const nir_search_variable search28_0 = {
   8217    { nir_search_value_variable, 0 },
   8218    0, /* a */
   8219    false,
   8220    nir_type_invalid,
   8221    NULL,
   8222 };
   8223 
   8224 #include "compiler/nir/nir_search_helpers.h"
   8225 static const nir_search_variable search28_1_0_0 = {
   8226    { nir_search_value_variable, 0 },
   8227    0, /* a */
   8228    false,
   8229    nir_type_invalid,
   8230    NULL,
   8231 };
   8232 #include "compiler/nir/nir_search_helpers.h"
   8233 static const nir_search_expression search28_1_0 = {
   8234    { nir_search_value_expression, 0 },
   8235    false,
   8236    nir_op_fneg,
   8237    { &search28_1_0_0.value },
   8238    NULL,
   8239 };
   8240 
   8241 #include "compiler/nir/nir_search_helpers.h"
   8242 static const nir_search_variable search28_1_1 = {
   8243    { nir_search_value_variable, 0 },
   8244    1, /* b */
   8245    false,
   8246    nir_type_invalid,
   8247    NULL,
   8248 };
   8249 #include "compiler/nir/nir_search_helpers.h"
   8250 static const nir_search_expression search28_1 = {
   8251    { nir_search_value_expression, 0 },
   8252    false,
   8253    nir_op_fadd,
   8254    { &search28_1_0.value, &search28_1_1.value },
   8255    NULL,
   8256 };
   8257 #include "compiler/nir/nir_search_helpers.h"
   8258 static const nir_search_expression search28 = {
   8259    { nir_search_value_expression, 0 },
   8260    true,
   8261    nir_op_fadd,
   8262    { &search28_0.value, &search28_1.value },
   8263    NULL,
   8264 };
   8265 
   8266 #include "compiler/nir/nir_search_helpers.h"
   8267 static const nir_search_variable replace28 = {
   8268    { nir_search_value_variable, 0 },
   8269    1, /* b */
   8270    false,
   8271    nir_type_invalid,
   8272    NULL,
   8273 };
   8274 
   8275 #include "compiler/nir/nir_search_helpers.h"
   8276 static const nir_search_variable search51_0_0 = {
   8277    { nir_search_value_variable, 0 },
   8278    0, /* a */
   8279    false,
   8280    nir_type_invalid,
   8281    NULL,
   8282 };
   8283 
   8284 #include "compiler/nir/nir_search_helpers.h"
   8285 static const nir_search_constant search51_0_1_0 = {
   8286    { nir_search_value_constant, 0 },
   8287    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   8288 };
   8289 
   8290 #include "compiler/nir/nir_search_helpers.h"
   8291 static const nir_search_variable search51_0_1_1_0_0 = {
   8292    { nir_search_value_variable, 0 },
   8293    1, /* c */
   8294    false,
   8295    nir_type_invalid,
   8296    NULL,
   8297 };
   8298 #include "compiler/nir/nir_search_helpers.h"
   8299 static const nir_search_expression search51_0_1_1_0 = {
   8300    { nir_search_value_expression, 0 },
   8301    false,
   8302    nir_op_b2f,
   8303    { &search51_0_1_1_0_0.value },
   8304    NULL,
   8305 };
   8306 #include "compiler/nir/nir_search_helpers.h"
   8307 static const nir_search_expression search51_0_1_1 = {
   8308    { nir_search_value_expression, 0 },
   8309    false,
   8310    nir_op_fneg,
   8311    { &search51_0_1_1_0.value },
   8312    NULL,
   8313 };
   8314 #include "compiler/nir/nir_search_helpers.h"
   8315 static const nir_search_expression search51_0_1 = {
   8316    { nir_search_value_expression, 0 },
   8317    false,
   8318    nir_op_fadd,
   8319    { &search51_0_1_0.value, &search51_0_1_1.value },
   8320    NULL,
   8321 };
   8322 #include "compiler/nir/nir_search_helpers.h"
   8323 static const nir_search_expression search51_0 = {
   8324    { nir_search_value_expression, 0 },
   8325    false,
   8326    nir_op_fmul,
   8327    { &search51_0_0.value, &search51_0_1.value },
   8328    NULL,
   8329 };
   8330 
   8331 #include "compiler/nir/nir_search_helpers.h"
   8332 static const nir_search_variable search51_1_0 = {
   8333    { nir_search_value_variable, 0 },
   8334    2, /* b */
   8335    false,
   8336    nir_type_invalid,
   8337    NULL,
   8338 };
   8339 
   8340 #include "compiler/nir/nir_search_helpers.h"
   8341 static const nir_search_variable search51_1_1_0 = {
   8342    { nir_search_value_variable, 0 },
   8343    1, /* c */
   8344    false,
   8345    nir_type_invalid,
   8346    NULL,
   8347 };
   8348 #include "compiler/nir/nir_search_helpers.h"
   8349 static const nir_search_expression search51_1_1 = {
   8350    { nir_search_value_expression, 0 },
   8351    false,
   8352    nir_op_b2f,
   8353    { &search51_1_1_0.value },
   8354    NULL,
   8355 };
   8356 #include "compiler/nir/nir_search_helpers.h"
   8357 static const nir_search_expression search51_1 = {
   8358    { nir_search_value_expression, 0 },
   8359    false,
   8360    nir_op_fmul,
   8361    { &search51_1_0.value, &search51_1_1.value },
   8362    NULL,
   8363 };
   8364 #include "compiler/nir/nir_search_helpers.h"
   8365 static const nir_search_expression search51 = {
   8366    { nir_search_value_expression, 0 },
   8367    true,
   8368    nir_op_fadd,
   8369    { &search51_0.value, &search51_1.value },
   8370    NULL,
   8371 };
   8372 
   8373 #include "compiler/nir/nir_search_helpers.h"
   8374 static const nir_search_variable replace51_0 = {
   8375    { nir_search_value_variable, 0 },
   8376    1, /* c */
   8377    false,
   8378    nir_type_invalid,
   8379    NULL,
   8380 };
   8381 
   8382 #include "compiler/nir/nir_search_helpers.h"
   8383 static const nir_search_variable replace51_1 = {
   8384    { nir_search_value_variable, 0 },
   8385    2, /* b */
   8386    false,
   8387    nir_type_invalid,
   8388    NULL,
   8389 };
   8390 
   8391 #include "compiler/nir/nir_search_helpers.h"
   8392 static const nir_search_variable replace51_2 = {
   8393    { nir_search_value_variable, 0 },
   8394    0, /* a */
   8395    false,
   8396    nir_type_invalid,
   8397    NULL,
   8398 };
   8399 #include "compiler/nir/nir_search_helpers.h"
   8400 static const nir_search_expression replace51 = {
   8401    { nir_search_value_expression, 0 },
   8402    false,
   8403    nir_op_bcsel,
   8404    { &replace51_0.value, &replace51_1.value, &replace51_2.value },
   8405    NULL,
   8406 };
   8407 
   8408 #include "compiler/nir/nir_search_helpers.h"
   8409 static const nir_search_variable search52_0_0 = {
   8410    { nir_search_value_variable, 0 },
   8411    0, /* a */
   8412    false,
   8413    nir_type_invalid,
   8414    NULL,
   8415 };
   8416 
   8417 #include "compiler/nir/nir_search_helpers.h"
   8418 static const nir_search_constant search52_0_1_0 = {
   8419    { nir_search_value_constant, 0 },
   8420    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   8421 };
   8422 
   8423 #include "compiler/nir/nir_search_helpers.h"
   8424 static const nir_search_variable search52_0_1_1_0 = {
   8425    { nir_search_value_variable, 0 },
   8426    1, /* c */
   8427    false,
   8428    nir_type_invalid,
   8429    NULL,
   8430 };
   8431 #include "compiler/nir/nir_search_helpers.h"
   8432 static const nir_search_expression search52_0_1_1 = {
   8433    { nir_search_value_expression, 0 },
   8434    false,
   8435    nir_op_fneg,
   8436    { &search52_0_1_1_0.value },
   8437    NULL,
   8438 };
   8439 #include "compiler/nir/nir_search_helpers.h"
   8440 static const nir_search_expression search52_0_1 = {
   8441    { nir_search_value_expression, 0 },
   8442    false,
   8443    nir_op_fadd,
   8444    { &search52_0_1_0.value, &search52_0_1_1.value },
   8445    NULL,
   8446 };
   8447 #include "compiler/nir/nir_search_helpers.h"
   8448 static const nir_search_expression search52_0 = {
   8449    { nir_search_value_expression, 0 },
   8450    false,
   8451    nir_op_fmul,
   8452    { &search52_0_0.value, &search52_0_1.value },
   8453    NULL,
   8454 };
   8455 
   8456 #include "compiler/nir/nir_search_helpers.h"
   8457 static const nir_search_variable search52_1_0 = {
   8458    { nir_search_value_variable, 0 },
   8459    2, /* b */
   8460    false,
   8461    nir_type_invalid,
   8462    NULL,
   8463 };
   8464 
   8465 #include "compiler/nir/nir_search_helpers.h"
   8466 static const nir_search_variable search52_1_1 = {
   8467    { nir_search_value_variable, 0 },
   8468    1, /* c */
   8469    false,
   8470    nir_type_invalid,
   8471    NULL,
   8472 };
   8473 #include "compiler/nir/nir_search_helpers.h"
   8474 static const nir_search_expression search52_1 = {
   8475    { nir_search_value_expression, 0 },
   8476    false,
   8477    nir_op_fmul,
   8478    { &search52_1_0.value, &search52_1_1.value },
   8479    NULL,
   8480 };
   8481 #include "compiler/nir/nir_search_helpers.h"
   8482 static const nir_search_expression search52 = {
   8483    { nir_search_value_expression, 32 },
   8484    true,
   8485    nir_op_fadd,
   8486    { &search52_0.value, &search52_1.value },
   8487    NULL,
   8488 };
   8489 
   8490 #include "compiler/nir/nir_search_helpers.h"
   8491 static const nir_search_variable replace52_0 = {
   8492    { nir_search_value_variable, 0 },
   8493    0, /* a */
   8494    false,
   8495    nir_type_invalid,
   8496    NULL,
   8497 };
   8498 
   8499 #include "compiler/nir/nir_search_helpers.h"
   8500 static const nir_search_variable replace52_1 = {
   8501    { nir_search_value_variable, 0 },
   8502    2, /* b */
   8503    false,
   8504    nir_type_invalid,
   8505    NULL,
   8506 };
   8507 
   8508 #include "compiler/nir/nir_search_helpers.h"
   8509 static const nir_search_variable replace52_2 = {
   8510    { nir_search_value_variable, 0 },
   8511    1, /* c */
   8512    false,
   8513    nir_type_invalid,
   8514    NULL,
   8515 };
   8516 #include "compiler/nir/nir_search_helpers.h"
   8517 static const nir_search_expression replace52 = {
   8518    { nir_search_value_expression, 0 },
   8519    false,
   8520    nir_op_flrp,
   8521    { &replace52_0.value, &replace52_1.value, &replace52_2.value },
   8522    NULL,
   8523 };
   8524 
   8525 #include "compiler/nir/nir_search_helpers.h"
   8526 static const nir_search_variable search53_0_0 = {
   8527    { nir_search_value_variable, 0 },
   8528    0, /* a */
   8529    false,
   8530    nir_type_invalid,
   8531    NULL,
   8532 };
   8533 
   8534 #include "compiler/nir/nir_search_helpers.h"
   8535 static const nir_search_constant search53_0_1_0 = {
   8536    { nir_search_value_constant, 0 },
   8537    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   8538 };
   8539 
   8540 #include "compiler/nir/nir_search_helpers.h"
   8541 static const nir_search_variable search53_0_1_1_0 = {
   8542    { nir_search_value_variable, 0 },
   8543    1, /* c */
   8544    false,
   8545    nir_type_invalid,
   8546    NULL,
   8547 };
   8548 #include "compiler/nir/nir_search_helpers.h"
   8549 static const nir_search_expression search53_0_1_1 = {
   8550    { nir_search_value_expression, 0 },
   8551    false,
   8552    nir_op_fneg,
   8553    { &search53_0_1_1_0.value },
   8554    NULL,
   8555 };
   8556 #include "compiler/nir/nir_search_helpers.h"
   8557 static const nir_search_expression search53_0_1 = {
   8558    { nir_search_value_expression, 0 },
   8559    false,
   8560    nir_op_fadd,
   8561    { &search53_0_1_0.value, &search53_0_1_1.value },
   8562    NULL,
   8563 };
   8564 #include "compiler/nir/nir_search_helpers.h"
   8565 static const nir_search_expression search53_0 = {
   8566    { nir_search_value_expression, 0 },
   8567    false,
   8568    nir_op_fmul,
   8569    { &search53_0_0.value, &search53_0_1.value },
   8570    NULL,
   8571 };
   8572 
   8573 #include "compiler/nir/nir_search_helpers.h"
   8574 static const nir_search_variable search53_1_0 = {
   8575    { nir_search_value_variable, 0 },
   8576    2, /* b */
   8577    false,
   8578    nir_type_invalid,
   8579    NULL,
   8580 };
   8581 
   8582 #include "compiler/nir/nir_search_helpers.h"
   8583 static const nir_search_variable search53_1_1 = {
   8584    { nir_search_value_variable, 0 },
   8585    1, /* c */
   8586    false,
   8587    nir_type_invalid,
   8588    NULL,
   8589 };
   8590 #include "compiler/nir/nir_search_helpers.h"
   8591 static const nir_search_expression search53_1 = {
   8592    { nir_search_value_expression, 0 },
   8593    false,
   8594    nir_op_fmul,
   8595    { &search53_1_0.value, &search53_1_1.value },
   8596    NULL,
   8597 };
   8598 #include "compiler/nir/nir_search_helpers.h"
   8599 static const nir_search_expression search53 = {
   8600    { nir_search_value_expression, 64 },
   8601    true,
   8602    nir_op_fadd,
   8603    { &search53_0.value, &search53_1.value },
   8604    NULL,
   8605 };
   8606 
   8607 #include "compiler/nir/nir_search_helpers.h"
   8608 static const nir_search_variable replace53_0 = {
   8609    { nir_search_value_variable, 0 },
   8610    0, /* a */
   8611    false,
   8612    nir_type_invalid,
   8613    NULL,
   8614 };
   8615 
   8616 #include "compiler/nir/nir_search_helpers.h"
   8617 static const nir_search_variable replace53_1 = {
   8618    { nir_search_value_variable, 0 },
   8619    2, /* b */
   8620    false,
   8621    nir_type_invalid,
   8622    NULL,
   8623 };
   8624 
   8625 #include "compiler/nir/nir_search_helpers.h"
   8626 static const nir_search_variable replace53_2 = {
   8627    { nir_search_value_variable, 0 },
   8628    1, /* c */
   8629    false,
   8630    nir_type_invalid,
   8631    NULL,
   8632 };
   8633 #include "compiler/nir/nir_search_helpers.h"
   8634 static const nir_search_expression replace53 = {
   8635    { nir_search_value_expression, 0 },
   8636    false,
   8637    nir_op_flrp,
   8638    { &replace53_0.value, &replace53_1.value, &replace53_2.value },
   8639    NULL,
   8640 };
   8641 
   8642 #include "compiler/nir/nir_search_helpers.h"
   8643 static const nir_search_variable search54_0 = {
   8644    { nir_search_value_variable, 0 },
   8645    0, /* a */
   8646    false,
   8647    nir_type_invalid,
   8648    NULL,
   8649 };
   8650 
   8651 #include "compiler/nir/nir_search_helpers.h"
   8652 static const nir_search_variable search54_1_0_0 = {
   8653    { nir_search_value_variable, 0 },
   8654    1, /* c */
   8655    false,
   8656    nir_type_invalid,
   8657    NULL,
   8658 };
   8659 #include "compiler/nir/nir_search_helpers.h"
   8660 static const nir_search_expression search54_1_0 = {
   8661    { nir_search_value_expression, 0 },
   8662    false,
   8663    nir_op_b2f,
   8664    { &search54_1_0_0.value },
   8665    NULL,
   8666 };
   8667 
   8668 #include "compiler/nir/nir_search_helpers.h"
   8669 static const nir_search_variable search54_1_1_0 = {
   8670    { nir_search_value_variable, 0 },
   8671    2, /* b */
   8672    false,
   8673    nir_type_invalid,
   8674    NULL,
   8675 };
   8676 
   8677 #include "compiler/nir/nir_search_helpers.h"
   8678 static const nir_search_variable search54_1_1_1_0 = {
   8679    { nir_search_value_variable, 0 },
   8680    0, /* a */
   8681    false,
   8682    nir_type_invalid,
   8683    NULL,
   8684 };
   8685 #include "compiler/nir/nir_search_helpers.h"
   8686 static const nir_search_expression search54_1_1_1 = {
   8687    { nir_search_value_expression, 0 },
   8688    false,
   8689    nir_op_fneg,
   8690    { &search54_1_1_1_0.value },
   8691    NULL,
   8692 };
   8693 #include "compiler/nir/nir_search_helpers.h"
   8694 static const nir_search_expression search54_1_1 = {
   8695    { nir_search_value_expression, 0 },
   8696    false,
   8697    nir_op_fadd,
   8698    { &search54_1_1_0.value, &search54_1_1_1.value },
   8699    NULL,
   8700 };
   8701 #include "compiler/nir/nir_search_helpers.h"
   8702 static const nir_search_expression search54_1 = {
   8703    { nir_search_value_expression, 0 },
   8704    false,
   8705    nir_op_fmul,
   8706    { &search54_1_0.value, &search54_1_1.value },
   8707    NULL,
   8708 };
   8709 #include "compiler/nir/nir_search_helpers.h"
   8710 static const nir_search_expression search54 = {
   8711    { nir_search_value_expression, 0 },
   8712    true,
   8713    nir_op_fadd,
   8714    { &search54_0.value, &search54_1.value },
   8715    NULL,
   8716 };
   8717 
   8718 #include "compiler/nir/nir_search_helpers.h"
   8719 static const nir_search_variable replace54_0 = {
   8720    { nir_search_value_variable, 0 },
   8721    1, /* c */
   8722    false,
   8723    nir_type_invalid,
   8724    NULL,
   8725 };
   8726 
   8727 #include "compiler/nir/nir_search_helpers.h"
   8728 static const nir_search_variable replace54_1 = {
   8729    { nir_search_value_variable, 0 },
   8730    2, /* b */
   8731    false,
   8732    nir_type_invalid,
   8733    NULL,
   8734 };
   8735 
   8736 #include "compiler/nir/nir_search_helpers.h"
   8737 static const nir_search_variable replace54_2 = {
   8738    { nir_search_value_variable, 0 },
   8739    0, /* a */
   8740    false,
   8741    nir_type_invalid,
   8742    NULL,
   8743 };
   8744 #include "compiler/nir/nir_search_helpers.h"
   8745 static const nir_search_expression replace54 = {
   8746    { nir_search_value_expression, 0 },
   8747    false,
   8748    nir_op_bcsel,
   8749    { &replace54_0.value, &replace54_1.value, &replace54_2.value },
   8750    NULL,
   8751 };
   8752 
   8753 #include "compiler/nir/nir_search_helpers.h"
   8754 static const nir_search_variable search55_0 = {
   8755    { nir_search_value_variable, 0 },
   8756    0, /* a */
   8757    false,
   8758    nir_type_invalid,
   8759    NULL,
   8760 };
   8761 
   8762 #include "compiler/nir/nir_search_helpers.h"
   8763 static const nir_search_variable search55_1_0 = {
   8764    { nir_search_value_variable, 0 },
   8765    1, /* c */
   8766    false,
   8767    nir_type_invalid,
   8768    NULL,
   8769 };
   8770 
   8771 #include "compiler/nir/nir_search_helpers.h"
   8772 static const nir_search_variable search55_1_1_0 = {
   8773    { nir_search_value_variable, 0 },
   8774    2, /* b */
   8775    false,
   8776    nir_type_invalid,
   8777    NULL,
   8778 };
   8779 
   8780 #include "compiler/nir/nir_search_helpers.h"
   8781 static const nir_search_variable search55_1_1_1_0 = {
   8782    { nir_search_value_variable, 0 },
   8783    0, /* a */
   8784    false,
   8785    nir_type_invalid,
   8786    NULL,
   8787 };
   8788 #include "compiler/nir/nir_search_helpers.h"
   8789 static const nir_search_expression search55_1_1_1 = {
   8790    { nir_search_value_expression, 0 },
   8791    false,
   8792    nir_op_fneg,
   8793    { &search55_1_1_1_0.value },
   8794    NULL,
   8795 };
   8796 #include "compiler/nir/nir_search_helpers.h"
   8797 static const nir_search_expression search55_1_1 = {
   8798    { nir_search_value_expression, 0 },
   8799    false,
   8800    nir_op_fadd,
   8801    { &search55_1_1_0.value, &search55_1_1_1.value },
   8802    NULL,
   8803 };
   8804 #include "compiler/nir/nir_search_helpers.h"
   8805 static const nir_search_expression search55_1 = {
   8806    { nir_search_value_expression, 0 },
   8807    false,
   8808    nir_op_fmul,
   8809    { &search55_1_0.value, &search55_1_1.value },
   8810    NULL,
   8811 };
   8812 #include "compiler/nir/nir_search_helpers.h"
   8813 static const nir_search_expression search55 = {
   8814    { nir_search_value_expression, 32 },
   8815    true,
   8816    nir_op_fadd,
   8817    { &search55_0.value, &search55_1.value },
   8818    NULL,
   8819 };
   8820 
   8821 #include "compiler/nir/nir_search_helpers.h"
   8822 static const nir_search_variable replace55_0 = {
   8823    { nir_search_value_variable, 0 },
   8824    0, /* a */
   8825    false,
   8826    nir_type_invalid,
   8827    NULL,
   8828 };
   8829 
   8830 #include "compiler/nir/nir_search_helpers.h"
   8831 static const nir_search_variable replace55_1 = {
   8832    { nir_search_value_variable, 0 },
   8833    2, /* b */
   8834    false,
   8835    nir_type_invalid,
   8836    NULL,
   8837 };
   8838 
   8839 #include "compiler/nir/nir_search_helpers.h"
   8840 static const nir_search_variable replace55_2 = {
   8841    { nir_search_value_variable, 0 },
   8842    1, /* c */
   8843    false,
   8844    nir_type_invalid,
   8845    NULL,
   8846 };
   8847 #include "compiler/nir/nir_search_helpers.h"
   8848 static const nir_search_expression replace55 = {
   8849    { nir_search_value_expression, 0 },
   8850    false,
   8851    nir_op_flrp,
   8852    { &replace55_0.value, &replace55_1.value, &replace55_2.value },
   8853    NULL,
   8854 };
   8855 
   8856 #include "compiler/nir/nir_search_helpers.h"
   8857 static const nir_search_variable search56_0 = {
   8858    { nir_search_value_variable, 0 },
   8859    0, /* a */
   8860    false,
   8861    nir_type_invalid,
   8862    NULL,
   8863 };
   8864 
   8865 #include "compiler/nir/nir_search_helpers.h"
   8866 static const nir_search_variable search56_1_0 = {
   8867    { nir_search_value_variable, 0 },
   8868    1, /* c */
   8869    false,
   8870    nir_type_invalid,
   8871    NULL,
   8872 };
   8873 
   8874 #include "compiler/nir/nir_search_helpers.h"
   8875 static const nir_search_variable search56_1_1_0 = {
   8876    { nir_search_value_variable, 0 },
   8877    2, /* b */
   8878    false,
   8879    nir_type_invalid,
   8880    NULL,
   8881 };
   8882 
   8883 #include "compiler/nir/nir_search_helpers.h"
   8884 static const nir_search_variable search56_1_1_1_0 = {
   8885    { nir_search_value_variable, 0 },
   8886    0, /* a */
   8887    false,
   8888    nir_type_invalid,
   8889    NULL,
   8890 };
   8891 #include "compiler/nir/nir_search_helpers.h"
   8892 static const nir_search_expression search56_1_1_1 = {
   8893    { nir_search_value_expression, 0 },
   8894    false,
   8895    nir_op_fneg,
   8896    { &search56_1_1_1_0.value },
   8897    NULL,
   8898 };
   8899 #include "compiler/nir/nir_search_helpers.h"
   8900 static const nir_search_expression search56_1_1 = {
   8901    { nir_search_value_expression, 0 },
   8902    false,
   8903    nir_op_fadd,
   8904    { &search56_1_1_0.value, &search56_1_1_1.value },
   8905    NULL,
   8906 };
   8907 #include "compiler/nir/nir_search_helpers.h"
   8908 static const nir_search_expression search56_1 = {
   8909    { nir_search_value_expression, 0 },
   8910    false,
   8911    nir_op_fmul,
   8912    { &search56_1_0.value, &search56_1_1.value },
   8913    NULL,
   8914 };
   8915 #include "compiler/nir/nir_search_helpers.h"
   8916 static const nir_search_expression search56 = {
   8917    { nir_search_value_expression, 64 },
   8918    true,
   8919    nir_op_fadd,
   8920    { &search56_0.value, &search56_1.value },
   8921    NULL,
   8922 };
   8923 
   8924 #include "compiler/nir/nir_search_helpers.h"
   8925 static const nir_search_variable replace56_0 = {
   8926    { nir_search_value_variable, 0 },
   8927    0, /* a */
   8928    false,
   8929    nir_type_invalid,
   8930    NULL,
   8931 };
   8932 
   8933 #include "compiler/nir/nir_search_helpers.h"
   8934 static const nir_search_variable replace56_1 = {
   8935    { nir_search_value_variable, 0 },
   8936    2, /* b */
   8937    false,
   8938    nir_type_invalid,
   8939    NULL,
   8940 };
   8941 
   8942 #include "compiler/nir/nir_search_helpers.h"
   8943 static const nir_search_variable replace56_2 = {
   8944    { nir_search_value_variable, 0 },
   8945    1, /* c */
   8946    false,
   8947    nir_type_invalid,
   8948    NULL,
   8949 };
   8950 #include "compiler/nir/nir_search_helpers.h"
   8951 static const nir_search_expression replace56 = {
   8952    { nir_search_value_expression, 0 },
   8953    false,
   8954    nir_op_flrp,
   8955    { &replace56_0.value, &replace56_1.value, &replace56_2.value },
   8956    NULL,
   8957 };
   8958 
   8959 #include "compiler/nir/nir_search_helpers.h"
   8960 static const nir_search_variable search58_0_0 = {
   8961    { nir_search_value_variable, 0 },
   8962    0, /* a */
   8963    false,
   8964    nir_type_invalid,
   8965    NULL,
   8966 };
   8967 
   8968 #include "compiler/nir/nir_search_helpers.h"
   8969 static const nir_search_variable search58_0_1 = {
   8970    { nir_search_value_variable, 0 },
   8971    1, /* b */
   8972    false,
   8973    nir_type_invalid,
   8974    NULL,
   8975 };
   8976 #include "compiler/nir/nir_search_helpers.h"
   8977 static const nir_search_expression search58_0 = {
   8978    { nir_search_value_expression, 0 },
   8979    false,
   8980    nir_op_fmul,
   8981    { &search58_0_0.value, &search58_0_1.value },
   8982    NULL,
   8983 };
   8984 
   8985 #include "compiler/nir/nir_search_helpers.h"
   8986 static const nir_search_variable search58_1 = {
   8987    { nir_search_value_variable, 0 },
   8988    2, /* c */
   8989    false,
   8990    nir_type_invalid,
   8991    NULL,
   8992 };
   8993 #include "compiler/nir/nir_search_helpers.h"
   8994 static const nir_search_expression search58 = {
   8995    { nir_search_value_expression, 0 },
   8996    true,
   8997    nir_op_fadd,
   8998    { &search58_0.value, &search58_1.value },
   8999    NULL,
   9000 };
   9001 
   9002 #include "compiler/nir/nir_search_helpers.h"
   9003 static const nir_search_variable replace58_0 = {
   9004    { nir_search_value_variable, 0 },
   9005    0, /* a */
   9006    false,
   9007    nir_type_invalid,
   9008    NULL,
   9009 };
   9010 
   9011 #include "compiler/nir/nir_search_helpers.h"
   9012 static const nir_search_variable replace58_1 = {
   9013    { nir_search_value_variable, 0 },
   9014    1, /* b */
   9015    false,
   9016    nir_type_invalid,
   9017    NULL,
   9018 };
   9019 
   9020 #include "compiler/nir/nir_search_helpers.h"
   9021 static const nir_search_variable replace58_2 = {
   9022    { nir_search_value_variable, 0 },
   9023    2, /* c */
   9024    false,
   9025    nir_type_invalid,
   9026    NULL,
   9027 };
   9028 #include "compiler/nir/nir_search_helpers.h"
   9029 static const nir_search_expression replace58 = {
   9030    { nir_search_value_expression, 0 },
   9031    false,
   9032    nir_op_ffma,
   9033    { &replace58_0.value, &replace58_1.value, &replace58_2.value },
   9034    NULL,
   9035 };
   9036 
   9037 #include "compiler/nir/nir_search_helpers.h"
   9038 static const nir_search_variable search203_0 = {
   9039    { nir_search_value_variable, 0 },
   9040    0, /* a */
   9041    false,
   9042    nir_type_invalid,
   9043    NULL,
   9044 };
   9045 
   9046 #include "compiler/nir/nir_search_helpers.h"
   9047 static const nir_search_constant search203_1_0 = {
   9048    { nir_search_value_constant, 0 },
   9049    nir_type_float, { 0x0 /* 0.0 */ },
   9050 };
   9051 
   9052 #include "compiler/nir/nir_search_helpers.h"
   9053 static const nir_search_variable search203_1_1 = {
   9054    { nir_search_value_variable, 0 },
   9055    1, /* b */
   9056    false,
   9057    nir_type_invalid,
   9058    NULL,
   9059 };
   9060 #include "compiler/nir/nir_search_helpers.h"
   9061 static const nir_search_expression search203_1 = {
   9062    { nir_search_value_expression, 0 },
   9063    false,
   9064    nir_op_fsub,
   9065    { &search203_1_0.value, &search203_1_1.value },
   9066    NULL,
   9067 };
   9068 #include "compiler/nir/nir_search_helpers.h"
   9069 static const nir_search_expression search203 = {
   9070    { nir_search_value_expression, 0 },
   9071    true,
   9072    nir_op_fadd,
   9073    { &search203_0.value, &search203_1.value },
   9074    NULL,
   9075 };
   9076 
   9077 #include "compiler/nir/nir_search_helpers.h"
   9078 static const nir_search_variable replace203_0 = {
   9079    { nir_search_value_variable, 0 },
   9080    0, /* a */
   9081    false,
   9082    nir_type_invalid,
   9083    NULL,
   9084 };
   9085 
   9086 #include "compiler/nir/nir_search_helpers.h"
   9087 static const nir_search_variable replace203_1 = {
   9088    { nir_search_value_variable, 0 },
   9089    1, /* b */
   9090    false,
   9091    nir_type_invalid,
   9092    NULL,
   9093 };
   9094 #include "compiler/nir/nir_search_helpers.h"
   9095 static const nir_search_expression replace203 = {
   9096    { nir_search_value_expression, 0 },
   9097    false,
   9098    nir_op_fsub,
   9099    { &replace203_0.value, &replace203_1.value },
   9100    NULL,
   9101 };
   9102 
   9103 #include "compiler/nir/nir_search_helpers.h"
   9104 static const nir_search_variable search211_0 = {
   9105    { nir_search_value_variable, 0 },
   9106    0, /* a */
   9107    true,
   9108    nir_type_invalid,
   9109    NULL,
   9110 };
   9111 
   9112 #include "compiler/nir/nir_search_helpers.h"
   9113 static const nir_search_variable search211_1_0 = {
   9114    { nir_search_value_variable, 0 },
   9115    1, /* b */
   9116    false,
   9117    nir_type_invalid,
   9118    NULL,
   9119 };
   9120 
   9121 #include "compiler/nir/nir_search_helpers.h"
   9122 static const nir_search_variable search211_1_1 = {
   9123    { nir_search_value_variable, 0 },
   9124    2, /* c */
   9125    true,
   9126    nir_type_invalid,
   9127    NULL,
   9128 };
   9129 #include "compiler/nir/nir_search_helpers.h"
   9130 static const nir_search_expression search211_1 = {
   9131    { nir_search_value_expression, 0 },
   9132    false,
   9133    nir_op_fadd,
   9134    { &search211_1_0.value, &search211_1_1.value },
   9135    NULL,
   9136 };
   9137 #include "compiler/nir/nir_search_helpers.h"
   9138 static const nir_search_expression search211 = {
   9139    { nir_search_value_expression, 0 },
   9140    true,
   9141    nir_op_fadd,
   9142    { &search211_0.value, &search211_1.value },
   9143    NULL,
   9144 };
   9145 
   9146 #include "compiler/nir/nir_search_helpers.h"
   9147 static const nir_search_variable replace211_0_0 = {
   9148    { nir_search_value_variable, 0 },
   9149    0, /* a */
   9150    false,
   9151    nir_type_invalid,
   9152    NULL,
   9153 };
   9154 
   9155 #include "compiler/nir/nir_search_helpers.h"
   9156 static const nir_search_variable replace211_0_1 = {
   9157    { nir_search_value_variable, 0 },
   9158    2, /* c */
   9159    false,
   9160    nir_type_invalid,
   9161    NULL,
   9162 };
   9163 #include "compiler/nir/nir_search_helpers.h"
   9164 static const nir_search_expression replace211_0 = {
   9165    { nir_search_value_expression, 0 },
   9166    false,
   9167    nir_op_fadd,
   9168    { &replace211_0_0.value, &replace211_0_1.value },
   9169    NULL,
   9170 };
   9171 
   9172 #include "compiler/nir/nir_search_helpers.h"
   9173 static const nir_search_variable replace211_1 = {
   9174    { nir_search_value_variable, 0 },
   9175    1, /* b */
   9176    false,
   9177    nir_type_invalid,
   9178    NULL,
   9179 };
   9180 #include "compiler/nir/nir_search_helpers.h"
   9181 static const nir_search_expression replace211 = {
   9182    { nir_search_value_expression, 0 },
   9183    false,
   9184    nir_op_fadd,
   9185    { &replace211_0.value, &replace211_1.value },
   9186    NULL,
   9187 };
   9188 
   9189 static const struct transform nir_opt_algebraic_fadd_xforms[] = {
   9190    { &search17, &replace17.value, 0 },
   9191    { &search21, &replace21.value, 0 },
   9192    { &search23, &replace23.value, 0 },
   9193    { &search27, &replace27.value, 0 },
   9194    { &search28, &replace28.value, 0 },
   9195    { &search51, &replace51.value, 2 },
   9196    { &search52, &replace52.value, 5 },
   9197    { &search53, &replace53.value, 6 },
   9198    { &search54, &replace54.value, 2 },
   9199    { &search55, &replace55.value, 5 },
   9200    { &search56, &replace56.value, 6 },
   9201    { &search58, &replace58.value, 8 },
   9202    { &search203, &replace203.value, 0 },
   9203    { &search211, &replace211.value, 0 },
   9204 };
   9205 
   9206 #include "compiler/nir/nir_search_helpers.h"
   9207 static const nir_search_variable search59_0_0_0 = {
   9208    { nir_search_value_variable, 0 },
   9209    0, /* a */
   9210    false,
   9211    nir_type_invalid,
   9212    NULL,
   9213 };
   9214 
   9215 #include "compiler/nir/nir_search_helpers.h"
   9216 static const nir_search_variable search59_0_0_1 = {
   9217    { nir_search_value_variable, 0 },
   9218    1, /* b */
   9219    true,
   9220    nir_type_invalid,
   9221    NULL,
   9222 };
   9223 #include "compiler/nir/nir_search_helpers.h"
   9224 static const nir_search_expression search59_0_0 = {
   9225    { nir_search_value_expression, 0 },
   9226    false,
   9227    nir_op_imul,
   9228    { &search59_0_0_0.value, &search59_0_0_1.value },
   9229    NULL,
   9230 };
   9231 
   9232 #include "compiler/nir/nir_search_helpers.h"
   9233 static const nir_search_variable search59_0_1 = {
   9234    { nir_search_value_variable, 0 },
   9235    2, /* c */
   9236    true,
   9237    nir_type_invalid,
   9238    NULL,
   9239 };
   9240 #include "compiler/nir/nir_search_helpers.h"
   9241 static const nir_search_expression search59_0 = {
   9242    { nir_search_value_expression, 0 },
   9243    false,
   9244    nir_op_iadd,
   9245    { &search59_0_0.value, &search59_0_1.value },
   9246    NULL,
   9247 };
   9248 
   9249 #include "compiler/nir/nir_search_helpers.h"
   9250 static const nir_search_variable search59_1 = {
   9251    { nir_search_value_variable, 0 },
   9252    3, /* d */
   9253    true,
   9254    nir_type_invalid,
   9255    NULL,
   9256 };
   9257 #include "compiler/nir/nir_search_helpers.h"
   9258 static const nir_search_expression search59 = {
   9259    { nir_search_value_expression, 0 },
   9260    false,
   9261    nir_op_ishl,
   9262    { &search59_0.value, &search59_1.value },
   9263    NULL,
   9264 };
   9265 
   9266 #include "compiler/nir/nir_search_helpers.h"
   9267 static const nir_search_variable replace59_0_0 = {
   9268    { nir_search_value_variable, 0 },
   9269    0, /* a */
   9270    false,
   9271    nir_type_invalid,
   9272    NULL,
   9273 };
   9274 
   9275 #include "compiler/nir/nir_search_helpers.h"
   9276 static const nir_search_variable replace59_0_1_0 = {
   9277    { nir_search_value_variable, 0 },
   9278    1, /* b */
   9279    false,
   9280    nir_type_invalid,
   9281    NULL,
   9282 };
   9283 
   9284 #include "compiler/nir/nir_search_helpers.h"
   9285 static const nir_search_variable replace59_0_1_1 = {
   9286    { nir_search_value_variable, 0 },
   9287    3, /* d */
   9288    false,
   9289    nir_type_invalid,
   9290    NULL,
   9291 };
   9292 #include "compiler/nir/nir_search_helpers.h"
   9293 static const nir_search_expression replace59_0_1 = {
   9294    { nir_search_value_expression, 0 },
   9295    false,
   9296    nir_op_ishl,
   9297    { &replace59_0_1_0.value, &replace59_0_1_1.value },
   9298    NULL,
   9299 };
   9300 #include "compiler/nir/nir_search_helpers.h"
   9301 static const nir_search_expression replace59_0 = {
   9302    { nir_search_value_expression, 0 },
   9303    false,
   9304    nir_op_imul,
   9305    { &replace59_0_0.value, &replace59_0_1.value },
   9306    NULL,
   9307 };
   9308 
   9309 #include "compiler/nir/nir_search_helpers.h"
   9310 static const nir_search_variable replace59_1_0 = {
   9311    { nir_search_value_variable, 0 },
   9312    2, /* c */
   9313    false,
   9314    nir_type_invalid,
   9315    NULL,
   9316 };
   9317 
   9318 #include "compiler/nir/nir_search_helpers.h"
   9319 static const nir_search_variable replace59_1_1 = {
   9320    { nir_search_value_variable, 0 },
   9321    3, /* d */
   9322    false,
   9323    nir_type_invalid,
   9324    NULL,
   9325 };
   9326 #include "compiler/nir/nir_search_helpers.h"
   9327 static const nir_search_expression replace59_1 = {
   9328    { nir_search_value_expression, 0 },
   9329    false,
   9330    nir_op_ishl,
   9331    { &replace59_1_0.value, &replace59_1_1.value },
   9332    NULL,
   9333 };
   9334 #include "compiler/nir/nir_search_helpers.h"
   9335 static const nir_search_expression replace59 = {
   9336    { nir_search_value_expression, 0 },
   9337    false,
   9338    nir_op_iadd,
   9339    { &replace59_0.value, &replace59_1.value },
   9340    NULL,
   9341 };
   9342 
   9343 #include "compiler/nir/nir_search_helpers.h"
   9344 static const nir_search_variable search60_0_0 = {
   9345    { nir_search_value_variable, 0 },
   9346    0, /* a */
   9347    false,
   9348    nir_type_invalid,
   9349    NULL,
   9350 };
   9351 
   9352 #include "compiler/nir/nir_search_helpers.h"
   9353 static const nir_search_variable search60_0_1 = {
   9354    { nir_search_value_variable, 0 },
   9355    1, /* b */
   9356    true,
   9357    nir_type_invalid,
   9358    NULL,
   9359 };
   9360 #include "compiler/nir/nir_search_helpers.h"
   9361 static const nir_search_expression search60_0 = {
   9362    { nir_search_value_expression, 0 },
   9363    false,
   9364    nir_op_imul,
   9365    { &search60_0_0.value, &search60_0_1.value },
   9366    NULL,
   9367 };
   9368 
   9369 #include "compiler/nir/nir_search_helpers.h"
   9370 static const nir_search_variable search60_1 = {
   9371    { nir_search_value_variable, 0 },
   9372    2, /* c */
   9373    true,
   9374    nir_type_invalid,
   9375    NULL,
   9376 };
   9377 #include "compiler/nir/nir_search_helpers.h"
   9378 static const nir_search_expression search60 = {
   9379    { nir_search_value_expression, 0 },
   9380    false,
   9381    nir_op_ishl,
   9382    { &search60_0.value, &search60_1.value },
   9383    NULL,
   9384 };
   9385 
   9386 #include "compiler/nir/nir_search_helpers.h"
   9387 static const nir_search_variable replace60_0 = {
   9388    { nir_search_value_variable, 0 },
   9389    0, /* a */
   9390    false,
   9391    nir_type_invalid,
   9392    NULL,
   9393 };
   9394 
   9395 #include "compiler/nir/nir_search_helpers.h"
   9396 static const nir_search_variable replace60_1_0 = {
   9397    { nir_search_value_variable, 0 },
   9398    1, /* b */
   9399    false,
   9400    nir_type_invalid,
   9401    NULL,
   9402 };
   9403 
   9404 #include "compiler/nir/nir_search_helpers.h"
   9405 static const nir_search_variable replace60_1_1 = {
   9406    { nir_search_value_variable, 0 },
   9407    2, /* c */
   9408    false,
   9409    nir_type_invalid,
   9410    NULL,
   9411 };
   9412 #include "compiler/nir/nir_search_helpers.h"
   9413 static const nir_search_expression replace60_1 = {
   9414    { nir_search_value_expression, 0 },
   9415    false,
   9416    nir_op_ishl,
   9417    { &replace60_1_0.value, &replace60_1_1.value },
   9418    NULL,
   9419 };
   9420 #include "compiler/nir/nir_search_helpers.h"
   9421 static const nir_search_expression replace60 = {
   9422    { nir_search_value_expression, 0 },
   9423    false,
   9424    nir_op_imul,
   9425    { &replace60_0.value, &replace60_1.value },
   9426    NULL,
   9427 };
   9428 
   9429 #include "compiler/nir/nir_search_helpers.h"
   9430 static const nir_search_constant search134_0 = {
   9431    { nir_search_value_constant, 0 },
   9432    nir_type_int, { 0x0 /* 0 */ },
   9433 };
   9434 
   9435 #include "compiler/nir/nir_search_helpers.h"
   9436 static const nir_search_variable search134_1 = {
   9437    { nir_search_value_variable, 0 },
   9438    0, /* a */
   9439    false,
   9440    nir_type_invalid,
   9441    NULL,
   9442 };
   9443 #include "compiler/nir/nir_search_helpers.h"
   9444 static const nir_search_expression search134 = {
   9445    { nir_search_value_expression, 0 },
   9446    false,
   9447    nir_op_ishl,
   9448    { &search134_0.value, &search134_1.value },
   9449    NULL,
   9450 };
   9451 
   9452 #include "compiler/nir/nir_search_helpers.h"
   9453 static const nir_search_constant replace134 = {
   9454    { nir_search_value_constant, 0 },
   9455    nir_type_int, { 0x0 /* 0 */ },
   9456 };
   9457 
   9458 #include "compiler/nir/nir_search_helpers.h"
   9459 static const nir_search_variable search135_0 = {
   9460    { nir_search_value_variable, 0 },
   9461    0, /* a */
   9462    false,
   9463    nir_type_invalid,
   9464    NULL,
   9465 };
   9466 
   9467 #include "compiler/nir/nir_search_helpers.h"
   9468 static const nir_search_constant search135_1 = {
   9469    { nir_search_value_constant, 0 },
   9470    nir_type_int, { 0x0 /* 0 */ },
   9471 };
   9472 #include "compiler/nir/nir_search_helpers.h"
   9473 static const nir_search_expression search135 = {
   9474    { nir_search_value_expression, 0 },
   9475    false,
   9476    nir_op_ishl,
   9477    { &search135_0.value, &search135_1.value },
   9478    NULL,
   9479 };
   9480 
   9481 #include "compiler/nir/nir_search_helpers.h"
   9482 static const nir_search_variable replace135 = {
   9483    { nir_search_value_variable, 0 },
   9484    0, /* a */
   9485    false,
   9486    nir_type_invalid,
   9487    NULL,
   9488 };
   9489 
   9490 static const struct transform nir_opt_algebraic_ishl_xforms[] = {
   9491    { &search59, &replace59.value, 0 },
   9492    { &search60, &replace60.value, 0 },
   9493    { &search134, &replace134.value, 0 },
   9494    { &search135, &replace135.value, 0 },
   9495 };
   9496 
   9497 #include "compiler/nir/nir_search_helpers.h"
   9498 static const nir_search_variable search217_0 = {
   9499    { nir_search_value_variable, 0 },
   9500    0, /* a */
   9501    false,
   9502    nir_type_invalid,
   9503    NULL,
   9504 };
   9505 
   9506 #include "compiler/nir/nir_search_helpers.h"
   9507 static const nir_search_variable search217_1 = {
   9508    { nir_search_value_variable, 0 },
   9509    1, /* b */
   9510    false,
   9511    nir_type_invalid,
   9512    NULL,
   9513 };
   9514 #include "compiler/nir/nir_search_helpers.h"
   9515 static const nir_search_expression search217 = {
   9516    { nir_search_value_expression, 32 },
   9517    false,
   9518    nir_op_usub_borrow,
   9519    { &search217_0.value, &search217_1.value },
   9520    NULL,
   9521 };
   9522 
   9523 #include "compiler/nir/nir_search_helpers.h"
   9524 static const nir_search_variable replace217_0_0 = {
   9525    { nir_search_value_variable, 0 },
   9526    0, /* a */
   9527    false,
   9528    nir_type_invalid,
   9529    NULL,
   9530 };
   9531 
   9532 #include "compiler/nir/nir_search_helpers.h"
   9533 static const nir_search_variable replace217_0_1 = {
   9534    { nir_search_value_variable, 0 },
   9535    1, /* b */
   9536    false,
   9537    nir_type_invalid,
   9538    NULL,
   9539 };
   9540 #include "compiler/nir/nir_search_helpers.h"
   9541 static const nir_search_expression replace217_0 = {
   9542    { nir_search_value_expression, 0 },
   9543    false,
   9544    nir_op_ult,
   9545    { &replace217_0_0.value, &replace217_0_1.value },
   9546    NULL,
   9547 };
   9548 #include "compiler/nir/nir_search_helpers.h"
   9549 static const nir_search_expression replace217 = {
   9550    { nir_search_value_expression, 0 },
   9551    false,
   9552    nir_op_b2i,
   9553    { &replace217_0.value },
   9554    NULL,
   9555 };
   9556 
   9557 static const struct transform nir_opt_algebraic_usub_borrow_xforms[] = {
   9558    { &search217, &replace217.value, 24 },
   9559 };
   9560 
   9561 #include "compiler/nir/nir_search_helpers.h"
   9562 static const nir_search_variable search143_0_0 = {
   9563    { nir_search_value_variable, 0 },
   9564    0, /* a */
   9565    false,
   9566    nir_type_invalid,
   9567    NULL,
   9568 };
   9569 #include "compiler/nir/nir_search_helpers.h"
   9570 static const nir_search_expression search143_0 = {
   9571    { nir_search_value_expression, 0 },
   9572    false,
   9573    nir_op_fexp2,
   9574    { &search143_0_0.value },
   9575    NULL,
   9576 };
   9577 #include "compiler/nir/nir_search_helpers.h"
   9578 static const nir_search_expression search143 = {
   9579    { nir_search_value_expression, 0 },
   9580    true,
   9581    nir_op_flog2,
   9582    { &search143_0.value },
   9583    NULL,
   9584 };
   9585 
   9586 #include "compiler/nir/nir_search_helpers.h"
   9587 static const nir_search_variable replace143 = {
   9588    { nir_search_value_variable, 0 },
   9589    0, /* a */
   9590    false,
   9591    nir_type_invalid,
   9592    NULL,
   9593 };
   9594 
   9595 #include "compiler/nir/nir_search_helpers.h"
   9596 static const nir_search_variable search156_0_0 = {
   9597    { nir_search_value_variable, 0 },
   9598    0, /* a */
   9599    false,
   9600    nir_type_invalid,
   9601    NULL,
   9602 };
   9603 #include "compiler/nir/nir_search_helpers.h"
   9604 static const nir_search_expression search156_0 = {
   9605    { nir_search_value_expression, 0 },
   9606    false,
   9607    nir_op_fsqrt,
   9608    { &search156_0_0.value },
   9609    NULL,
   9610 };
   9611 #include "compiler/nir/nir_search_helpers.h"
   9612 static const nir_search_expression search156 = {
   9613    { nir_search_value_expression, 0 },
   9614    true,
   9615    nir_op_flog2,
   9616    { &search156_0.value },
   9617    NULL,
   9618 };
   9619 
   9620 #include "compiler/nir/nir_search_helpers.h"
   9621 static const nir_search_constant replace156_0 = {
   9622    { nir_search_value_constant, 0 },
   9623    nir_type_float, { 0x3fe0000000000000 /* 0.5 */ },
   9624 };
   9625 
   9626 #include "compiler/nir/nir_search_helpers.h"
   9627 static const nir_search_variable replace156_1_0 = {
   9628    { nir_search_value_variable, 0 },
   9629    0, /* a */
   9630    false,
   9631    nir_type_invalid,
   9632    NULL,
   9633 };
   9634 #include "compiler/nir/nir_search_helpers.h"
   9635 static const nir_search_expression replace156_1 = {
   9636    { nir_search_value_expression, 0 },
   9637    false,
   9638    nir_op_flog2,
   9639    { &replace156_1_0.value },
   9640    NULL,
   9641 };
   9642 #include "compiler/nir/nir_search_helpers.h"
   9643 static const nir_search_expression replace156 = {
   9644    { nir_search_value_expression, 0 },
   9645    false,
   9646    nir_op_fmul,
   9647    { &replace156_0.value, &replace156_1.value },
   9648    NULL,
   9649 };
   9650 
   9651 #include "compiler/nir/nir_search_helpers.h"
   9652 static const nir_search_variable search157_0_0 = {
   9653    { nir_search_value_variable, 0 },
   9654    0, /* a */
   9655    false,
   9656    nir_type_invalid,
   9657    NULL,
   9658 };
   9659 #include "compiler/nir/nir_search_helpers.h"
   9660 static const nir_search_expression search157_0 = {
   9661    { nir_search_value_expression, 0 },
   9662    false,
   9663    nir_op_frcp,
   9664    { &search157_0_0.value },
   9665    NULL,
   9666 };
   9667 #include "compiler/nir/nir_search_helpers.h"
   9668 static const nir_search_expression search157 = {
   9669    { nir_search_value_expression, 0 },
   9670    true,
   9671    nir_op_flog2,
   9672    { &search157_0.value },
   9673    NULL,
   9674 };
   9675 
   9676 #include "compiler/nir/nir_search_helpers.h"
   9677 static const nir_search_variable replace157_0_0 = {
   9678    { nir_search_value_variable, 0 },
   9679    0, /* a */
   9680    false,
   9681    nir_type_invalid,
   9682    NULL,
   9683 };
   9684 #include "compiler/nir/nir_search_helpers.h"
   9685 static const nir_search_expression replace157_0 = {
   9686    { nir_search_value_expression, 0 },
   9687    false,
   9688    nir_op_flog2,
   9689    { &replace157_0_0.value },
   9690    NULL,
   9691 };
   9692 #include "compiler/nir/nir_search_helpers.h"
   9693 static const nir_search_expression replace157 = {
   9694    { nir_search_value_expression, 0 },
   9695    false,
   9696    nir_op_fneg,
   9697    { &replace157_0.value },
   9698    NULL,
   9699 };
   9700 
   9701 #include "compiler/nir/nir_search_helpers.h"
   9702 static const nir_search_variable search158_0_0 = {
   9703    { nir_search_value_variable, 0 },
   9704    0, /* a */
   9705    false,
   9706    nir_type_invalid,
   9707    NULL,
   9708 };
   9709 #include "compiler/nir/nir_search_helpers.h"
   9710 static const nir_search_expression search158_0 = {
   9711    { nir_search_value_expression, 0 },
   9712    false,
   9713    nir_op_frsq,
   9714    { &search158_0_0.value },
   9715    NULL,
   9716 };
   9717 #include "compiler/nir/nir_search_helpers.h"
   9718 static const nir_search_expression search158 = {
   9719    { nir_search_value_expression, 0 },
   9720    true,
   9721    nir_op_flog2,
   9722    { &search158_0.value },
   9723    NULL,
   9724 };
   9725 
   9726 #include "compiler/nir/nir_search_helpers.h"
   9727 static const nir_search_constant replace158_0 = {
   9728    { nir_search_value_constant, 0 },
   9729    nir_type_float, { 0xbfe0000000000000L /* -0.5 */ },
   9730 };
   9731 
   9732 #include "compiler/nir/nir_search_helpers.h"
   9733 static const nir_search_variable replace158_1_0 = {
   9734    { nir_search_value_variable, 0 },
   9735    0, /* a */
   9736    false,
   9737    nir_type_invalid,
   9738    NULL,
   9739 };
   9740 #include "compiler/nir/nir_search_helpers.h"
   9741 static const nir_search_expression replace158_1 = {
   9742    { nir_search_value_expression, 0 },
   9743    false,
   9744    nir_op_flog2,
   9745    { &replace158_1_0.value },
   9746    NULL,
   9747 };
   9748 #include "compiler/nir/nir_search_helpers.h"
   9749 static const nir_search_expression replace158 = {
   9750    { nir_search_value_expression, 0 },
   9751    false,
   9752    nir_op_fmul,
   9753    { &replace158_0.value, &replace158_1.value },
   9754    NULL,
   9755 };
   9756 
   9757 #include "compiler/nir/nir_search_helpers.h"
   9758 static const nir_search_variable search159_0_0 = {
   9759    { nir_search_value_variable, 0 },
   9760    0, /* a */
   9761    false,
   9762    nir_type_invalid,
   9763    NULL,
   9764 };
   9765 
   9766 #include "compiler/nir/nir_search_helpers.h"
   9767 static const nir_search_variable search159_0_1 = {
   9768    { nir_search_value_variable, 0 },
   9769    1, /* b */
   9770    false,
   9771    nir_type_invalid,
   9772    NULL,
   9773 };
   9774 #include "compiler/nir/nir_search_helpers.h"
   9775 static const nir_search_expression search159_0 = {
   9776    { nir_search_value_expression, 0 },
   9777    false,
   9778    nir_op_fpow,
   9779    { &search159_0_0.value, &search159_0_1.value },
   9780    NULL,
   9781 };
   9782 #include "compiler/nir/nir_search_helpers.h"
   9783 static const nir_search_expression search159 = {
   9784    { nir_search_value_expression, 0 },
   9785    true,
   9786    nir_op_flog2,
   9787    { &search159_0.value },
   9788    NULL,
   9789 };
   9790 
   9791 #include "compiler/nir/nir_search_helpers.h"
   9792 static const nir_search_variable replace159_0 = {
   9793    { nir_search_value_variable, 0 },
   9794    1, /* b */
   9795    false,
   9796    nir_type_invalid,
   9797    NULL,
   9798 };
   9799 
   9800 #include "compiler/nir/nir_search_helpers.h"
   9801 static const nir_search_variable replace159_1_0 = {
   9802    { nir_search_value_variable, 0 },
   9803    0, /* a */
   9804    false,
   9805    nir_type_invalid,
   9806    NULL,
   9807 };
   9808 #include "compiler/nir/nir_search_helpers.h"
   9809 static const nir_search_expression replace159_1 = {
   9810    { nir_search_value_expression, 0 },
   9811    false,
   9812    nir_op_flog2,
   9813    { &replace159_1_0.value },
   9814    NULL,
   9815 };
   9816 #include "compiler/nir/nir_search_helpers.h"
   9817 static const nir_search_expression replace159 = {
   9818    { nir_search_value_expression, 0 },
   9819    false,
   9820    nir_op_fmul,
   9821    { &replace159_0.value, &replace159_1.value },
   9822    NULL,
   9823 };
   9824 
   9825 static const struct transform nir_opt_algebraic_flog2_xforms[] = {
   9826    { &search143, &replace143.value, 0 },
   9827    { &search156, &replace156.value, 0 },
   9828    { &search157, &replace157.value, 0 },
   9829    { &search158, &replace158.value, 0 },
   9830    { &search159, &replace159.value, 0 },
   9831 };
   9832 
   9833 #include "compiler/nir/nir_search_helpers.h"
   9834 static const nir_search_variable search61_0_0 = {
   9835    { nir_search_value_variable, 0 },
   9836    0, /* a */
   9837    false,
   9838    nir_type_invalid,
   9839    NULL,
   9840 };
   9841 
   9842 #include "compiler/nir/nir_search_helpers.h"
   9843 static const nir_search_variable search61_0_1 = {
   9844    { nir_search_value_variable, 0 },
   9845    1, /* b */
   9846    false,
   9847    nir_type_invalid,
   9848    NULL,
   9849 };
   9850 #include "compiler/nir/nir_search_helpers.h"
   9851 static const nir_search_expression search61_0 = {
   9852    { nir_search_value_expression, 0 },
   9853    false,
   9854    nir_op_flt,
   9855    { &search61_0_0.value, &search61_0_1.value },
   9856    NULL,
   9857 };
   9858 #include "compiler/nir/nir_search_helpers.h"
   9859 static const nir_search_expression search61 = {
   9860    { nir_search_value_expression, 0 },
   9861    true,
   9862    nir_op_inot,
   9863    { &search61_0.value },
   9864    NULL,
   9865 };
   9866 
   9867 #include "compiler/nir/nir_search_helpers.h"
   9868 static const nir_search_variable replace61_0 = {
   9869    { nir_search_value_variable, 0 },
   9870    0, /* a */
   9871    false,
   9872    nir_type_invalid,
   9873    NULL,
   9874 };
   9875 
   9876 #include "compiler/nir/nir_search_helpers.h"
   9877 static const nir_search_variable replace61_1 = {
   9878    { nir_search_value_variable, 0 },
   9879    1, /* b */
   9880    false,
   9881    nir_type_invalid,
   9882    NULL,
   9883 };
   9884 #include "compiler/nir/nir_search_helpers.h"
   9885 static const nir_search_expression replace61 = {
   9886    { nir_search_value_expression, 0 },
   9887    false,
   9888    nir_op_fge,
   9889    { &replace61_0.value, &replace61_1.value },
   9890    NULL,
   9891 };
   9892 
   9893 #include "compiler/nir/nir_search_helpers.h"
   9894 static const nir_search_variable search62_0_0 = {
   9895    { nir_search_value_variable, 0 },
   9896    0, /* a */
   9897    false,
   9898    nir_type_invalid,
   9899    NULL,
   9900 };
   9901 
   9902 #include "compiler/nir/nir_search_helpers.h"
   9903 static const nir_search_variable search62_0_1 = {
   9904    { nir_search_value_variable, 0 },
   9905    1, /* b */
   9906    false,
   9907    nir_type_invalid,
   9908    NULL,
   9909 };
   9910 #include "compiler/nir/nir_search_helpers.h"
   9911 static const nir_search_expression search62_0 = {
   9912    { nir_search_value_expression, 0 },
   9913    false,
   9914    nir_op_fge,
   9915    { &search62_0_0.value, &search62_0_1.value },
   9916    NULL,
   9917 };
   9918 #include "compiler/nir/nir_search_helpers.h"
   9919 static const nir_search_expression search62 = {
   9920    { nir_search_value_expression, 0 },
   9921    true,
   9922    nir_op_inot,
   9923    { &search62_0.value },
   9924    NULL,
   9925 };
   9926 
   9927 #include "compiler/nir/nir_search_helpers.h"
   9928 static const nir_search_variable replace62_0 = {
   9929    { nir_search_value_variable, 0 },
   9930    0, /* a */
   9931    false,
   9932    nir_type_invalid,
   9933    NULL,
   9934 };
   9935 
   9936 #include "compiler/nir/nir_search_helpers.h"
   9937 static const nir_search_variable replace62_1 = {
   9938    { nir_search_value_variable, 0 },
   9939    1, /* b */
   9940    false,
   9941    nir_type_invalid,
   9942    NULL,
   9943 };
   9944 #include "compiler/nir/nir_search_helpers.h"
   9945 static const nir_search_expression replace62 = {
   9946    { nir_search_value_expression, 0 },
   9947    false,
   9948    nir_op_flt,
   9949    { &replace62_0.value, &replace62_1.value },
   9950    NULL,
   9951 };
   9952 
   9953 #include "compiler/nir/nir_search_helpers.h"
   9954 static const nir_search_variable search63_0_0 = {
   9955    { nir_search_value_variable, 0 },
   9956    0, /* a */
   9957    false,
   9958    nir_type_invalid,
   9959    NULL,
   9960 };
   9961 
   9962 #include "compiler/nir/nir_search_helpers.h"
   9963 static const nir_search_variable search63_0_1 = {
   9964    { nir_search_value_variable, 0 },
   9965    1, /* b */
   9966    false,
   9967    nir_type_invalid,
   9968    NULL,
   9969 };
   9970 #include "compiler/nir/nir_search_helpers.h"
   9971 static const nir_search_expression search63_0 = {
   9972    { nir_search_value_expression, 0 },
   9973    false,
   9974    nir_op_feq,
   9975    { &search63_0_0.value, &search63_0_1.value },
   9976    NULL,
   9977 };
   9978 #include "compiler/nir/nir_search_helpers.h"
   9979 static const nir_search_expression search63 = {
   9980    { nir_search_value_expression, 0 },
   9981    true,
   9982    nir_op_inot,
   9983    { &search63_0.value },
   9984    NULL,
   9985 };
   9986 
   9987 #include "compiler/nir/nir_search_helpers.h"
   9988 static const nir_search_variable replace63_0 = {
   9989    { nir_search_value_variable, 0 },
   9990    0, /* a */
   9991    false,
   9992    nir_type_invalid,
   9993    NULL,
   9994 };
   9995 
   9996 #include "compiler/nir/nir_search_helpers.h"
   9997 static const nir_search_variable replace63_1 = {
   9998    { nir_search_value_variable, 0 },
   9999    1, /* b */
   10000    false,
   10001    nir_type_invalid,
   10002    NULL,
   10003 };
   10004 #include "compiler/nir/nir_search_helpers.h"
   10005 static const nir_search_expression replace63 = {
   10006    { nir_search_value_expression, 0 },
   10007    false,
   10008    nir_op_fne,
   10009    { &replace63_0.value, &replace63_1.value },
   10010    NULL,
   10011 };
   10012 
   10013 #include "compiler/nir/nir_search_helpers.h"
   10014 static const nir_search_variable search64_0_0 = {
   10015    { nir_search_value_variable, 0 },
   10016    0, /* a */
   10017    false,
   10018    nir_type_invalid,
   10019    NULL,
   10020 };
   10021 
   10022 #include "compiler/nir/nir_search_helpers.h"
   10023 static const nir_search_variable search64_0_1 = {
   10024    { nir_search_value_variable, 0 },
   10025    1, /* b */
   10026    false,
   10027    nir_type_invalid,
   10028    NULL,
   10029 };
   10030 #include "compiler/nir/nir_search_helpers.h"
   10031 static const nir_search_expression search64_0 = {
   10032    { nir_search_value_expression, 0 },
   10033    false,
   10034    nir_op_fne,
   10035    { &search64_0_0.value, &search64_0_1.value },
   10036    NULL,
   10037 };
   10038 #include "compiler/nir/nir_search_helpers.h"
   10039 static const nir_search_expression search64 = {
   10040    { nir_search_value_expression, 0 },
   10041    true,
   10042    nir_op_inot,
   10043    { &search64_0.value },
   10044    NULL,
   10045 };
   10046 
   10047 #include "compiler/nir/nir_search_helpers.h"
   10048 static const nir_search_variable replace64_0 = {
   10049    { nir_search_value_variable, 0 },
   10050    0, /* a */
   10051    false,
   10052    nir_type_invalid,
   10053    NULL,
   10054 };
   10055 
   10056 #include "compiler/nir/nir_search_helpers.h"
   10057 static const nir_search_variable replace64_1 = {
   10058    { nir_search_value_variable, 0 },
   10059    1, /* b */
   10060    false,
   10061    nir_type_invalid,
   10062    NULL,
   10063 };
   10064 #include "compiler/nir/nir_search_helpers.h"
   10065 static const nir_search_expression replace64 = {
   10066    { nir_search_value_expression, 0 },
   10067    false,
   10068    nir_op_feq,
   10069    { &replace64_0.value, &replace64_1.value },
   10070    NULL,
   10071 };
   10072 
   10073 #include "compiler/nir/nir_search_helpers.h"
   10074 static const nir_search_variable search65_0_0 = {
   10075    { nir_search_value_variable, 0 },
   10076    0, /* a */
   10077    false,
   10078    nir_type_invalid,
   10079    NULL,
   10080 };
   10081 
   10082 #include "compiler/nir/nir_search_helpers.h"
   10083 static const nir_search_variable search65_0_1 = {
   10084    { nir_search_value_variable, 0 },
   10085    1, /* b */
   10086    false,
   10087    nir_type_invalid,
   10088    NULL,
   10089 };
   10090 #include "compiler/nir/nir_search_helpers.h"
   10091 static const nir_search_expression search65_0 = {
   10092    { nir_search_value_expression, 0 },
   10093    false,
   10094    nir_op_ilt,
   10095    { &search65_0_0.value, &search65_0_1.value },
   10096    NULL,
   10097 };
   10098 #include "compiler/nir/nir_search_helpers.h"
   10099 static const nir_search_expression search65 = {
   10100    { nir_search_value_expression, 0 },
   10101    false,
   10102    nir_op_inot,
   10103    { &search65_0.value },
   10104    NULL,
   10105 };
   10106 
   10107 #include "compiler/nir/nir_search_helpers.h"
   10108 static const nir_search_variable replace65_0 = {
   10109    { nir_search_value_variable, 0 },
   10110    0, /* a */
   10111    false,
   10112    nir_type_invalid,
   10113    NULL,
   10114 };
   10115 
   10116 #include "compiler/nir/nir_search_helpers.h"
   10117 static const nir_search_variable replace65_1 = {
   10118    { nir_search_value_variable, 0 },
   10119    1, /* b */
   10120    false,
   10121    nir_type_invalid,
   10122    NULL,
   10123 };
   10124 #include "compiler/nir/nir_search_helpers.h"
   10125 static const nir_search_expression replace65 = {
   10126    { nir_search_value_expression, 0 },
   10127    false,
   10128    nir_op_ige,
   10129    { &replace65_0.value, &replace65_1.value },
   10130    NULL,
   10131 };
   10132 
   10133 #include "compiler/nir/nir_search_helpers.h"
   10134 static const nir_search_variable search66_0_0 = {
   10135    { nir_search_value_variable, 0 },
   10136    0, /* a */
   10137    false,
   10138    nir_type_invalid,
   10139    NULL,
   10140 };
   10141 
   10142 #include "compiler/nir/nir_search_helpers.h"
   10143 static const nir_search_variable search66_0_1 = {
   10144    { nir_search_value_variable, 0 },
   10145    1, /* b */
   10146    false,
   10147    nir_type_invalid,
   10148    NULL,
   10149 };
   10150 #include "compiler/nir/nir_search_helpers.h"
   10151 static const nir_search_expression search66_0 = {
   10152    { nir_search_value_expression, 0 },
   10153    false,
   10154    nir_op_ige,
   10155    { &search66_0_0.value, &search66_0_1.value },
   10156    NULL,
   10157 };
   10158 #include "compiler/nir/nir_search_helpers.h"
   10159 static const nir_search_expression search66 = {
   10160    { nir_search_value_expression, 0 },
   10161    false,
   10162    nir_op_inot,
   10163    { &search66_0.value },
   10164    NULL,
   10165 };
   10166 
   10167 #include "compiler/nir/nir_search_helpers.h"
   10168 static const nir_search_variable replace66_0 = {
   10169    { nir_search_value_variable, 0 },
   10170    0, /* a */
   10171    false,
   10172    nir_type_invalid,
   10173    NULL,
   10174 };
   10175 
   10176 #include "compiler/nir/nir_search_helpers.h"
   10177 static const nir_search_variable replace66_1 = {
   10178    { nir_search_value_variable, 0 },
   10179    1, /* b */
   10180    false,
   10181    nir_type_invalid,
   10182    NULL,
   10183 };
   10184 #include "compiler/nir/nir_search_helpers.h"
   10185 static const nir_search_expression replace66 = {
   10186    { nir_search_value_expression, 0 },
   10187    false,
   10188    nir_op_ilt,
   10189    { &replace66_0.value, &replace66_1.value },
   10190    NULL,
   10191 };
   10192 
   10193 #include "compiler/nir/nir_search_helpers.h"
   10194 static const nir_search_variable search67_0_0 = {
   10195    { nir_search_value_variable, 0 },
   10196    0, /* a */
   10197    false,
   10198    nir_type_invalid,
   10199    NULL,
   10200 };
   10201 
   10202 #include "compiler/nir/nir_search_helpers.h"
   10203 static const nir_search_variable search67_0_1 = {
   10204    { nir_search_value_variable, 0 },
   10205    1, /* b */
   10206    false,
   10207    nir_type_invalid,
   10208    NULL,
   10209 };
   10210 #include "compiler/nir/nir_search_helpers.h"
   10211 static const nir_search_expression search67_0 = {
   10212    { nir_search_value_expression, 0 },
   10213    false,
   10214    nir_op_ieq,
   10215    { &search67_0_0.value, &search67_0_1.value },
   10216    NULL,
   10217 };
   10218 #include "compiler/nir/nir_search_helpers.h"
   10219 static const nir_search_expression search67 = {
   10220    { nir_search_value_expression, 0 },
   10221    false,
   10222    nir_op_inot,
   10223    { &search67_0.value },
   10224    NULL,
   10225 };
   10226 
   10227 #include "compiler/nir/nir_search_helpers.h"
   10228 static const nir_search_variable replace67_0 = {
   10229    { nir_search_value_variable, 0 },
   10230    0, /* a */
   10231    false,
   10232    nir_type_invalid,
   10233    NULL,
   10234 };
   10235 
   10236 #include "compiler/nir/nir_search_helpers.h"
   10237 static const nir_search_variable replace67_1 = {
   10238    { nir_search_value_variable, 0 },
   10239    1, /* b */
   10240    false,
   10241    nir_type_invalid,
   10242    NULL,
   10243 };
   10244 #include "compiler/nir/nir_search_helpers.h"
   10245 static const nir_search_expression replace67 = {
   10246    { nir_search_value_expression, 0 },
   10247    false,
   10248    nir_op_ine,
   10249    { &replace67_0.value, &replace67_1.value },
   10250    NULL,
   10251 };
   10252 
   10253 #include "compiler/nir/nir_search_helpers.h"
   10254 static const nir_search_variable search68_0_0 = {
   10255    { nir_search_value_variable, 0 },
   10256    0, /* a */
   10257    false,
   10258    nir_type_invalid,
   10259    NULL,
   10260 };
   10261 
   10262 #include "compiler/nir/nir_search_helpers.h"
   10263 static const nir_search_variable search68_0_1 = {
   10264    { nir_search_value_variable, 0 },
   10265    1, /* b */
   10266    false,
   10267    nir_type_invalid,
   10268    NULL,
   10269 };
   10270 #include "compiler/nir/nir_search_helpers.h"
   10271 static const nir_search_expression search68_0 = {
   10272    { nir_search_value_expression, 0 },
   10273    false,
   10274    nir_op_ine,
   10275    { &search68_0_0.value, &search68_0_1.value },
   10276    NULL,
   10277 };
   10278 #include "compiler/nir/nir_search_helpers.h"
   10279 static const nir_search_expression search68 = {
   10280    { nir_search_value_expression, 0 },
   10281    false,
   10282    nir_op_inot,
   10283    { &search68_0.value },
   10284    NULL,
   10285 };
   10286 
   10287 #include "compiler/nir/nir_search_helpers.h"
   10288 static const nir_search_variable replace68_0 = {
   10289    { nir_search_value_variable, 0 },
   10290    0, /* a */
   10291    false,
   10292    nir_type_invalid,
   10293    NULL,
   10294 };
   10295 
   10296 #include "compiler/nir/nir_search_helpers.h"
   10297 static const nir_search_variable replace68_1 = {
   10298    { nir_search_value_variable, 0 },
   10299    1, /* b */
   10300    false,
   10301    nir_type_invalid,
   10302    NULL,
   10303 };
   10304 #include "compiler/nir/nir_search_helpers.h"
   10305 static const nir_search_expression replace68 = {
   10306    { nir_search_value_expression, 0 },
   10307    false,
   10308    nir_op_ieq,
   10309    { &replace68_0.value, &replace68_1.value },
   10310    NULL,
   10311 };
   10312 
   10313 #include "compiler/nir/nir_search_helpers.h"
   10314 static const nir_search_variable search131_0_0 = {
   10315    { nir_search_value_variable, 0 },
   10316    0, /* a */
   10317    false,
   10318    nir_type_invalid,
   10319    NULL,
   10320 };
   10321 #include "compiler/nir/nir_search_helpers.h"
   10322 static const nir_search_expression search131_0 = {
   10323    { nir_search_value_expression, 0 },
   10324    false,
   10325    nir_op_inot,
   10326    { &search131_0_0.value },
   10327    NULL,
   10328 };
   10329 #include "compiler/nir/nir_search_helpers.h"
   10330 static const nir_search_expression search131 = {
   10331    { nir_search_value_expression, 0 },
   10332    false,
   10333    nir_op_inot,
   10334    { &search131_0.value },
   10335    NULL,
   10336 };
   10337 
   10338 #include "compiler/nir/nir_search_helpers.h"
   10339 static const nir_search_variable replace131 = {
   10340    { nir_search_value_variable, 0 },
   10341    0, /* a */
   10342    false,
   10343    nir_type_invalid,
   10344    NULL,
   10345 };
   10346 
   10347 static const struct transform nir_opt_algebraic_inot_xforms[] = {
   10348    { &search61, &replace61.value, 0 },
   10349    { &search62, &replace62.value, 0 },
   10350    { &search63, &replace63.value, 0 },
   10351    { &search64, &replace64.value, 0 },
   10352    { &search65, &replace65.value, 0 },
   10353    { &search66, &replace66.value, 0 },
   10354    { &search67, &replace67.value, 0 },
   10355    { &search68, &replace68.value, 0 },
   10356    { &search131, &replace131.value, 0 },
   10357 };
   10358 
   10359 #include "compiler/nir/nir_search_helpers.h"
   10360 static const nir_search_variable search105_0 = {
   10361    { nir_search_value_variable, 0 },
   10362    0, /* a */
   10363    false,
   10364    nir_type_invalid,
   10365    NULL,
   10366 };
   10367 
   10368 #include "compiler/nir/nir_search_helpers.h"
   10369 static const nir_search_variable search105_1 = {
   10370    { nir_search_value_variable, 0 },
   10371    1, /* b */
   10372    false,
   10373    nir_type_invalid,
   10374    NULL,
   10375 };
   10376 #include "compiler/nir/nir_search_helpers.h"
   10377 static const nir_search_expression search105 = {
   10378    { nir_search_value_expression, 0 },
   10379    false,
   10380    nir_op_sne,
   10381    { &search105_0.value, &search105_1.value },
   10382    NULL,
   10383 };
   10384 
   10385 #include "compiler/nir/nir_search_helpers.h"
   10386 static const nir_search_variable replace105_0_0 = {
   10387    { nir_search_value_variable, 0 },
   10388    0, /* a */
   10389    false,
   10390    nir_type_invalid,
   10391    NULL,
   10392 };
   10393 
   10394 #include "compiler/nir/nir_search_helpers.h"
   10395 static const nir_search_variable replace105_0_1 = {
   10396    { nir_search_value_variable, 0 },
   10397    1, /* b */
   10398    false,
   10399    nir_type_invalid,
   10400    NULL,
   10401 };
   10402 #include "compiler/nir/nir_search_helpers.h"
   10403 static const nir_search_expression replace105_0 = {
   10404    { nir_search_value_expression, 0 },
   10405    false,
   10406    nir_op_fne,
   10407    { &replace105_0_0.value, &replace105_0_1.value },
   10408    NULL,
   10409 };
   10410 #include "compiler/nir/nir_search_helpers.h"
   10411 static const nir_search_expression replace105 = {
   10412    { nir_search_value_expression, 0 },
   10413    false,
   10414    nir_op_b2f,
   10415    { &replace105_0.value },
   10416    NULL,
   10417 };
   10418 
   10419 static const struct transform nir_opt_algebraic_sne_xforms[] = {
   10420    { &search105, &replace105.value, 11 },
   10421 };
   10422 
   10423 #include "compiler/nir/nir_search_helpers.h"
   10424 static const nir_search_variable search213_0 = {
   10425    { nir_search_value_variable, 0 },
   10426    0, /* a */
   10427    false,
   10428    nir_type_invalid,
   10429    NULL,
   10430 };
   10431 
   10432 #include "compiler/nir/nir_search_helpers.h"
   10433 static const nir_search_variable search213_1 = {
   10434    { nir_search_value_variable, 0 },
   10435    1, /* b */
   10436    false,
   10437    nir_type_invalid,
   10438    NULL,
   10439 };
   10440 #include "compiler/nir/nir_search_helpers.h"
   10441 static const nir_search_expression search213 = {
   10442    { nir_search_value_expression, 32 },
   10443    false,
   10444    nir_op_fmod,
   10445    { &search213_0.value, &search213_1.value },
   10446    NULL,
   10447 };
   10448 
   10449 #include "compiler/nir/nir_search_helpers.h"
   10450 static const nir_search_variable replace213_0 = {
   10451    { nir_search_value_variable, 0 },
   10452    0, /* a */
   10453    false,
   10454    nir_type_invalid,
   10455    NULL,
   10456 };
   10457 
   10458 #include "compiler/nir/nir_search_helpers.h"
   10459 static const nir_search_variable replace213_1_0 = {
   10460    { nir_search_value_variable, 0 },
   10461    1, /* b */
   10462    false,
   10463    nir_type_invalid,
   10464    NULL,
   10465 };
   10466 
   10467 #include "compiler/nir/nir_search_helpers.h"
   10468 static const nir_search_variable replace213_1_1_0_0 = {
   10469    { nir_search_value_variable, 0 },
   10470    0, /* a */
   10471    false,
   10472    nir_type_invalid,
   10473    NULL,
   10474 };
   10475 
   10476 #include "compiler/nir/nir_search_helpers.h"
   10477 static const nir_search_variable replace213_1_1_0_1 = {
   10478    { nir_search_value_variable, 0 },
   10479    1, /* b */
   10480    false,
   10481    nir_type_invalid,
   10482    NULL,
   10483 };
   10484 #include "compiler/nir/nir_search_helpers.h"
   10485 static const nir_search_expression replace213_1_1_0 = {
   10486    { nir_search_value_expression, 0 },
   10487    false,
   10488    nir_op_fdiv,
   10489    { &replace213_1_1_0_0.value, &replace213_1_1_0_1.value },
   10490    NULL,
   10491 };
   10492 #include "compiler/nir/nir_search_helpers.h"
   10493 static const nir_search_expression replace213_1_1 = {
   10494    { nir_search_value_expression, 0 },
   10495    false,
   10496    nir_op_ffloor,
   10497    { &replace213_1_1_0.value },
   10498    NULL,
   10499 };
   10500 #include "compiler/nir/nir_search_helpers.h"
   10501 static const nir_search_expression replace213_1 = {
   10502    { nir_search_value_expression, 0 },
   10503    false,
   10504    nir_op_fmul,
   10505    { &replace213_1_0.value, &replace213_1_1.value },
   10506    NULL,
   10507 };
   10508 #include "compiler/nir/nir_search_helpers.h"
   10509 static const nir_search_expression replace213 = {
   10510    { nir_search_value_expression, 0 },
   10511    false,
   10512    nir_op_fsub,
   10513    { &replace213_0.value, &replace213_1.value },
   10514    NULL,
   10515 };
   10516 
   10517 #include "compiler/nir/nir_search_helpers.h"
   10518 static const nir_search_variable search214_0 = {
   10519    { nir_search_value_variable, 0 },
   10520    0, /* a */
   10521    false,
   10522    nir_type_invalid,
   10523    NULL,
   10524 };
   10525 
   10526 #include "compiler/nir/nir_search_helpers.h"
   10527 static const nir_search_variable search214_1 = {
   10528    { nir_search_value_variable, 0 },
   10529    1, /* b */
   10530    false,
   10531    nir_type_invalid,
   10532    NULL,
   10533 };
   10534 #include "compiler/nir/nir_search_helpers.h"
   10535 static const nir_search_expression search214 = {
   10536    { nir_search_value_expression, 64 },
   10537    false,
   10538    nir_op_fmod,
   10539    { &search214_0.value, &search214_1.value },
   10540    NULL,
   10541 };
   10542 
   10543 #include "compiler/nir/nir_search_helpers.h"
   10544 static const nir_search_variable replace214_0 = {
   10545    { nir_search_value_variable, 0 },
   10546    0, /* a */
   10547    false,
   10548    nir_type_invalid,
   10549    NULL,
   10550 };
   10551 
   10552 #include "compiler/nir/nir_search_helpers.h"
   10553 static const nir_search_variable replace214_1_0 = {
   10554    { nir_search_value_variable, 0 },
   10555    1, /* b */
   10556    false,
   10557    nir_type_invalid,
   10558    NULL,
   10559 };
   10560 
   10561 #include "compiler/nir/nir_search_helpers.h"
   10562 static const nir_search_variable replace214_1_1_0_0 = {
   10563    { nir_search_value_variable, 0 },
   10564    0, /* a */
   10565    false,
   10566    nir_type_invalid,
   10567    NULL,
   10568 };
   10569 
   10570 #include "compiler/nir/nir_search_helpers.h"
   10571 static const nir_search_variable replace214_1_1_0_1 = {
   10572    { nir_search_value_variable, 0 },
   10573    1, /* b */
   10574    false,
   10575    nir_type_invalid,
   10576    NULL,
   10577 };
   10578 #include "compiler/nir/nir_search_helpers.h"
   10579 static const nir_search_expression replace214_1_1_0 = {
   10580    { nir_search_value_expression, 0 },
   10581    false,
   10582    nir_op_fdiv,
   10583    { &replace214_1_1_0_0.value, &replace214_1_1_0_1.value },
   10584    NULL,
   10585 };
   10586 #include "compiler/nir/nir_search_helpers.h"
   10587 static const nir_search_expression replace214_1_1 = {
   10588    { nir_search_value_expression, 0 },
   10589    false,
   10590    nir_op_ffloor,
   10591    { &replace214_1_1_0.value },
   10592    NULL,
   10593 };
   10594 #include "compiler/nir/nir_search_helpers.h"
   10595 static const nir_search_expression replace214_1 = {
   10596    { nir_search_value_expression, 0 },
   10597    false,
   10598    nir_op_fmul,
   10599    { &replace214_1_0.value, &replace214_1_1.value },
   10600    NULL,
   10601 };
   10602 #include "compiler/nir/nir_search_helpers.h"
   10603 static const nir_search_expression replace214 = {
   10604    { nir_search_value_expression, 0 },
   10605    false,
   10606    nir_op_fsub,
   10607    { &replace214_0.value, &replace214_1.value },
   10608    NULL,
   10609 };
   10610 
   10611 static const struct transform nir_opt_algebraic_fmod_xforms[] = {
   10612    { &search213, &replace213.value, 21 },
   10613    { &search214, &replace214.value, 22 },
   10614 };
   10615 
   10616 #include "compiler/nir/nir_search_helpers.h"
   10617 static const nir_search_variable search184_0_0 = {
   10618    { nir_search_value_variable, 0 },
   10619    0, /* a */
   10620    false,
   10621    nir_type_invalid,
   10622    NULL,
   10623 };
   10624 #include "compiler/nir/nir_search_helpers.h"
   10625 static const nir_search_expression search184_0 = {
   10626    { nir_search_value_expression, 0 },
   10627    false,
   10628    nir_op_ftrunc,
   10629    { &search184_0_0.value },
   10630    NULL,
   10631 };
   10632 #include "compiler/nir/nir_search_helpers.h"
   10633 static const nir_search_expression search184 = {
   10634    { nir_search_value_expression, 0 },
   10635    false,
   10636    nir_op_f2u,
   10637    { &search184_0.value },
   10638    NULL,
   10639 };
   10640 
   10641 #include "compiler/nir/nir_search_helpers.h"
   10642 static const nir_search_variable replace184_0 = {
   10643    { nir_search_value_variable, 0 },
   10644    0, /* a */
   10645    false,
   10646    nir_type_invalid,
   10647    NULL,
   10648 };
   10649 #include "compiler/nir/nir_search_helpers.h"
   10650 static const nir_search_expression replace184 = {
   10651    { nir_search_value_expression, 0 },
   10652    false,
   10653    nir_op_f2u,
   10654    { &replace184_0.value },
   10655    NULL,
   10656 };
   10657 
   10658 static const struct transform nir_opt_algebraic_f2u_xforms[] = {
   10659    { &search184, &replace184.value, 0 },
   10660 };
   10661 
   10662 #include "compiler/nir/nir_search_helpers.h"
   10663 static const nir_search_variable search181_0 = {
   10664    { nir_search_value_variable, 0 },
   10665    0, /* a */
   10666    false,
   10667    nir_type_invalid,
   10668    NULL,
   10669 };
   10670 
   10671 #include "compiler/nir/nir_search_helpers.h"
   10672 static const nir_search_variable search181_1 = {
   10673    { nir_search_value_variable, 0 },
   10674    1, /* b */
   10675    false,
   10676    nir_type_invalid,
   10677    NULL,
   10678 };
   10679 
   10680 #include "compiler/nir/nir_search_helpers.h"
   10681 static const nir_search_variable search181_2 = {
   10682    { nir_search_value_variable, 0 },
   10683    1, /* b */
   10684    false,
   10685    nir_type_invalid,
   10686    NULL,
   10687 };
   10688 #include "compiler/nir/nir_search_helpers.h"
   10689 static const nir_search_expression search181 = {
   10690    { nir_search_value_expression, 0 },
   10691    false,
   10692    nir_op_fcsel,
   10693    { &search181_0.value, &search181_1.value, &search181_2.value },
   10694    NULL,
   10695 };
   10696 
   10697 #include "compiler/nir/nir_search_helpers.h"
   10698 static const nir_search_variable replace181 = {
   10699    { nir_search_value_variable, 0 },
   10700    1, /* b */
   10701    false,
   10702    nir_type_invalid,
   10703    NULL,
   10704 };
   10705 
   10706 static const struct transform nir_opt_algebraic_fcsel_xforms[] = {
   10707    { &search181, &replace181.value, 0 },
   10708 };
   10709 
   10710 #include "compiler/nir/nir_search_helpers.h"
   10711 static const nir_search_variable search196_0 = {
   10712    { nir_search_value_variable, 0 },
   10713    0, /* a */
   10714    false,
   10715    nir_type_invalid,
   10716    NULL,
   10717 };
   10718 
   10719 #include "compiler/nir/nir_search_helpers.h"
   10720 static const nir_search_constant search196_1_0 = {
   10721    { nir_search_value_constant, 0 },
   10722    nir_type_int, { 0x0 /* 0 */ },
   10723 };
   10724 
   10725 #include "compiler/nir/nir_search_helpers.h"
   10726 static const nir_search_variable search196_1_1 = {
   10727    { nir_search_value_variable, 0 },
   10728    1, /* b */
   10729    false,
   10730    nir_type_invalid,
   10731    NULL,
   10732 };
   10733 #include "compiler/nir/nir_search_helpers.h"
   10734 static const nir_search_expression search196_1 = {
   10735    { nir_search_value_expression, 0 },
   10736    false,
   10737    nir_op_isub,
   10738    { &search196_1_0.value, &search196_1_1.value },
   10739    NULL,
   10740 };
   10741 #include "compiler/nir/nir_search_helpers.h"
   10742 static const nir_search_expression search196 = {
   10743    { nir_search_value_expression, 0 },
   10744    false,
   10745    nir_op_isub,
   10746    { &search196_0.value, &search196_1.value },
   10747    NULL,
   10748 };
   10749 
   10750 #include "compiler/nir/nir_search_helpers.h"
   10751 static const nir_search_variable replace196_0 = {
   10752    { nir_search_value_variable, 0 },
   10753    0, /* a */
   10754    false,
   10755    nir_type_invalid,
   10756    NULL,
   10757 };
   10758 
   10759 #include "compiler/nir/nir_search_helpers.h"
   10760 static const nir_search_variable replace196_1 = {
   10761    { nir_search_value_variable, 0 },
   10762    1, /* b */
   10763    false,
   10764    nir_type_invalid,
   10765    NULL,
   10766 };
   10767 #include "compiler/nir/nir_search_helpers.h"
   10768 static const nir_search_expression replace196 = {
   10769    { nir_search_value_expression, 0 },
   10770    false,
   10771    nir_op_iadd,
   10772    { &replace196_0.value, &replace196_1.value },
   10773    NULL,
   10774 };
   10775 
   10776 #include "compiler/nir/nir_search_helpers.h"
   10777 static const nir_search_variable search200_0 = {
   10778    { nir_search_value_variable, 0 },
   10779    0, /* a */
   10780    false,
   10781    nir_type_invalid,
   10782    NULL,
   10783 };
   10784 
   10785 #include "compiler/nir/nir_search_helpers.h"
   10786 static const nir_search_variable search200_1 = {
   10787    { nir_search_value_variable, 0 },
   10788    1, /* b */
   10789    false,
   10790    nir_type_invalid,
   10791    NULL,
   10792 };
   10793 #include "compiler/nir/nir_search_helpers.h"
   10794 static const nir_search_expression search200 = {
   10795    { nir_search_value_expression, 0 },
   10796    false,
   10797    nir_op_isub,
   10798    { &search200_0.value, &search200_1.value },
   10799    NULL,
   10800 };
   10801 
   10802 #include "compiler/nir/nir_search_helpers.h"
   10803 static const nir_search_variable replace200_0 = {
   10804    { nir_search_value_variable, 0 },
   10805    0, /* a */
   10806    false,
   10807    nir_type_invalid,
   10808    NULL,
   10809 };
   10810 
   10811 #include "compiler/nir/nir_search_helpers.h"
   10812 static const nir_search_variable replace200_1_0 = {
   10813    { nir_search_value_variable, 0 },
   10814    1, /* b */
   10815    false,
   10816    nir_type_invalid,
   10817    NULL,
   10818 };
   10819 #include "compiler/nir/nir_search_helpers.h"
   10820 static const nir_search_expression replace200_1 = {
   10821    { nir_search_value_expression, 0 },
   10822    false,
   10823    nir_op_ineg,
   10824    { &replace200_1_0.value },
   10825    NULL,
   10826 };
   10827 #include "compiler/nir/nir_search_helpers.h"
   10828 static const nir_search_expression replace200 = {
   10829    { nir_search_value_expression, 0 },
   10830    false,
   10831    nir_op_iadd,
   10832    { &replace200_0.value, &replace200_1.value },
   10833    NULL,
   10834 };
   10835 
   10836 static const struct transform nir_opt_algebraic_isub_xforms[] = {
   10837    { &search196, &replace196.value, 0 },
   10838    { &search200, &replace200.value, 19 },
   10839 };
   10840 
   10841 #include "compiler/nir/nir_search_helpers.h"
   10842 static const nir_search_variable search79_0 = {
   10843    { nir_search_value_variable, 0 },
   10844    0, /* a */
   10845    false,
   10846    nir_type_invalid,
   10847    NULL,
   10848 };
   10849 
   10850 #include "compiler/nir/nir_search_helpers.h"
   10851 static const nir_search_variable search79_1 = {
   10852    { nir_search_value_variable, 0 },
   10853    0, /* a */
   10854    false,
   10855    nir_type_invalid,
   10856    NULL,
   10857 };
   10858 #include "compiler/nir/nir_search_helpers.h"
   10859 static const nir_search_expression search79 = {
   10860    { nir_search_value_expression, 0 },
   10861    false,
   10862    nir_op_fmax,
   10863    { &search79_0.value, &search79_1.value },
   10864    NULL,
   10865 };
   10866 
   10867 #include "compiler/nir/nir_search_helpers.h"
   10868 static const nir_search_variable replace79 = {
   10869    { nir_search_value_variable, 0 },
   10870    0, /* a */
   10871    false,
   10872    nir_type_invalid,
   10873    NULL,
   10874 };
   10875 
   10876 #include "compiler/nir/nir_search_helpers.h"
   10877 static const nir_search_variable search85_0_0 = {
   10878    { nir_search_value_variable, 0 },
   10879    0, /* a */
   10880    false,
   10881    nir_type_invalid,
   10882    NULL,
   10883 };
   10884 
   10885 #include "compiler/nir/nir_search_helpers.h"
   10886 static const nir_search_constant search85_0_1 = {
   10887    { nir_search_value_constant, 0 },
   10888    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   10889 };
   10890 #include "compiler/nir/nir_search_helpers.h"
   10891 static const nir_search_expression search85_0 = {
   10892    { nir_search_value_expression, 0 },
   10893    false,
   10894    nir_op_fmin,
   10895    { &search85_0_0.value, &search85_0_1.value },
   10896    NULL,
   10897 };
   10898 
   10899 #include "compiler/nir/nir_search_helpers.h"
   10900 static const nir_search_constant search85_1 = {
   10901    { nir_search_value_constant, 0 },
   10902    nir_type_float, { 0x0 /* 0.0 */ },
   10903 };
   10904 #include "compiler/nir/nir_search_helpers.h"
   10905 static const nir_search_expression search85 = {
   10906    { nir_search_value_expression, 0 },
   10907    true,
   10908    nir_op_fmax,
   10909    { &search85_0.value, &search85_1.value },
   10910    NULL,
   10911 };
   10912 
   10913 #include "compiler/nir/nir_search_helpers.h"
   10914 static const nir_search_variable replace85_0 = {
   10915    { nir_search_value_variable, 0 },
   10916    0, /* a */
   10917    false,
   10918    nir_type_invalid,
   10919    NULL,
   10920 };
   10921 #include "compiler/nir/nir_search_helpers.h"
   10922 static const nir_search_expression replace85 = {
   10923    { nir_search_value_expression, 0 },
   10924    false,
   10925    nir_op_fsat,
   10926    { &replace85_0.value },
   10927    NULL,
   10928 };
   10929 
   10930 #include "compiler/nir/nir_search_helpers.h"
   10931 static const nir_search_variable search91_0_0 = {
   10932    { nir_search_value_variable, 0 },
   10933    0, /* a */
   10934    false,
   10935    nir_type_invalid,
   10936    NULL,
   10937 };
   10938 #include "compiler/nir/nir_search_helpers.h"
   10939 static const nir_search_expression search91_0 = {
   10940    { nir_search_value_expression, 0 },
   10941    false,
   10942    nir_op_fsat,
   10943    { &search91_0_0.value },
   10944    NULL,
   10945 };
   10946 
   10947 #include "compiler/nir/nir_search_helpers.h"
   10948 static const nir_search_variable search91_1 = {
   10949    { nir_search_value_variable, 32 },
   10950    1, /* b */
   10951    true,
   10952    nir_type_invalid,
   10953    (is_zero_to_one),
   10954 };
   10955 #include "compiler/nir/nir_search_helpers.h"
   10956 static const nir_search_expression search91 = {
   10957    { nir_search_value_expression, 0 },
   10958    false,
   10959    nir_op_fmax,
   10960    { &search91_0.value, &search91_1.value },
   10961    NULL,
   10962 };
   10963 
   10964 #include "compiler/nir/nir_search_helpers.h"
   10965 static const nir_search_variable replace91_0_0 = {
   10966    { nir_search_value_variable, 0 },
   10967    0, /* a */
   10968    false,
   10969    nir_type_invalid,
   10970    NULL,
   10971 };
   10972 
   10973 #include "compiler/nir/nir_search_helpers.h"
   10974 static const nir_search_variable replace91_0_1 = {
   10975    { nir_search_value_variable, 0 },
   10976    1, /* b */
   10977    false,
   10978    nir_type_invalid,
   10979    NULL,
   10980 };
   10981 #include "compiler/nir/nir_search_helpers.h"
   10982 static const nir_search_expression replace91_0 = {
   10983    { nir_search_value_expression, 0 },
   10984    false,
   10985    nir_op_fmax,
   10986    { &replace91_0_0.value, &replace91_0_1.value },
   10987    NULL,
   10988 };
   10989 #include "compiler/nir/nir_search_helpers.h"
   10990 static const nir_search_expression replace91 = {
   10991    { nir_search_value_expression, 0 },
   10992    false,
   10993    nir_op_fsat,
   10994    { &replace91_0.value },
   10995    NULL,
   10996 };
   10997 
   10998 static const struct transform nir_opt_algebraic_fmax_xforms[] = {
   10999    { &search79, &replace79.value, 0 },
   11000    { &search85, &replace85.value, 9 },
   11001    { &search91, &replace91.value, 0 },
   11002 };
   11003 
   11004 #include "compiler/nir/nir_search_helpers.h"
   11005 static const nir_search_variable search31_0 = {
   11006    { nir_search_value_variable, 0 },
   11007    0, /* a */
   11008    false,
   11009    nir_type_invalid,
   11010    NULL,
   11011 };
   11012 
   11013 #include "compiler/nir/nir_search_helpers.h"
   11014 static const nir_search_constant search31_1 = {
   11015    { nir_search_value_constant, 0 },
   11016    nir_type_int, { 0x0 /* 0 */ },
   11017 };
   11018 #include "compiler/nir/nir_search_helpers.h"
   11019 static const nir_search_expression search31 = {
   11020    { nir_search_value_expression, 0 },
   11021    false,
   11022    nir_op_umul_unorm_4x8,
   11023    { &search31_0.value, &search31_1.value },
   11024    NULL,
   11025 };
   11026 
   11027 #include "compiler/nir/nir_search_helpers.h"
   11028 static const nir_search_constant replace31 = {
   11029    { nir_search_value_constant, 0 },
   11030    nir_type_int, { 0x0 /* 0 */ },
   11031 };
   11032 
   11033 #include "compiler/nir/nir_search_helpers.h"
   11034 static const nir_search_variable search32_0 = {
   11035    { nir_search_value_variable, 0 },
   11036    0, /* a */
   11037    false,
   11038    nir_type_invalid,
   11039    NULL,
   11040 };
   11041 
   11042 #include "compiler/nir/nir_search_helpers.h"
   11043 static const nir_search_constant search32_1 = {
   11044    { nir_search_value_constant, 0 },
   11045    nir_type_int, { -0x1 /* -1 */ },
   11046 };
   11047 #include "compiler/nir/nir_search_helpers.h"
   11048 static const nir_search_expression search32 = {
   11049    { nir_search_value_expression, 0 },
   11050    false,
   11051    nir_op_umul_unorm_4x8,
   11052    { &search32_0.value, &search32_1.value },
   11053    NULL,
   11054 };
   11055 
   11056 #include "compiler/nir/nir_search_helpers.h"
   11057 static const nir_search_variable replace32 = {
   11058    { nir_search_value_variable, 0 },
   11059    0, /* a */
   11060    false,
   11061    nir_type_invalid,
   11062    NULL,
   11063 };
   11064 
   11065 static const struct transform nir_opt_algebraic_umul_unorm_4x8_xforms[] = {
   11066    { &search31, &replace31.value, 0 },
   11067    { &search32, &replace32.value, 0 },
   11068 };
   11069 
   11070 #include "compiler/nir/nir_search_helpers.h"
   11071 static const nir_search_variable search218_0 = {
   11072    { nir_search_value_variable, 0 },
   11073    0, /* base */
   11074    false,
   11075    nir_type_invalid,
   11076    NULL,
   11077 };
   11078 
   11079 #include "compiler/nir/nir_search_helpers.h"
   11080 static const nir_search_variable search218_1 = {
   11081    { nir_search_value_variable, 0 },
   11082    1, /* insert */
   11083    false,
   11084    nir_type_invalid,
   11085    NULL,
   11086 };
   11087 
   11088 #include "compiler/nir/nir_search_helpers.h"
   11089 static const nir_search_variable search218_2 = {
   11090    { nir_search_value_variable, 0 },
   11091    2, /* offset */
   11092    false,
   11093    nir_type_invalid,
   11094    NULL,
   11095 };
   11096 
   11097 #include "compiler/nir/nir_search_helpers.h"
   11098 static const nir_search_variable search218_3 = {
   11099    { nir_search_value_variable, 0 },
   11100    3, /* bits */
   11101    false,
   11102    nir_type_invalid,
   11103    NULL,
   11104 };
   11105 #include "compiler/nir/nir_search_helpers.h"
   11106 static const nir_search_expression search218 = {
   11107    { nir_search_value_expression, 0 },
   11108    false,
   11109    nir_op_bitfield_insert,
   11110    { &search218_0.value, &search218_1.value, &search218_2.value, &search218_3.value },
   11111    NULL,
   11112 };
   11113 
   11114 #include "compiler/nir/nir_search_helpers.h"
   11115 static const nir_search_constant replace218_0_0 = {
   11116    { nir_search_value_constant, 0 },
   11117    nir_type_int, { 0x1f /* 31 */ },
   11118 };
   11119 
   11120 #include "compiler/nir/nir_search_helpers.h"
   11121 static const nir_search_variable replace218_0_1 = {
   11122    { nir_search_value_variable, 0 },
   11123    3, /* bits */
   11124    false,
   11125    nir_type_invalid,
   11126    NULL,
   11127 };
   11128 #include "compiler/nir/nir_search_helpers.h"
   11129 static const nir_search_expression replace218_0 = {
   11130    { nir_search_value_expression, 0 },
   11131    false,
   11132    nir_op_ilt,
   11133    { &replace218_0_0.value, &replace218_0_1.value },
   11134    NULL,
   11135 };
   11136 
   11137 #include "compiler/nir/nir_search_helpers.h"
   11138 static const nir_search_variable replace218_1 = {
   11139    { nir_search_value_variable, 0 },
   11140    1, /* insert */
   11141    false,
   11142    nir_type_invalid,
   11143    NULL,
   11144 };
   11145 
   11146 #include "compiler/nir/nir_search_helpers.h"
   11147 static const nir_search_variable replace218_2_0_0 = {
   11148    { nir_search_value_variable, 0 },
   11149    3, /* bits */
   11150    false,
   11151    nir_type_invalid,
   11152    NULL,
   11153 };
   11154 
   11155 #include "compiler/nir/nir_search_helpers.h"
   11156 static const nir_search_variable replace218_2_0_1 = {
   11157    { nir_search_value_variable, 0 },
   11158    2, /* offset */
   11159    false,
   11160    nir_type_invalid,
   11161    NULL,
   11162 };
   11163 #include "compiler/nir/nir_search_helpers.h"
   11164 static const nir_search_expression replace218_2_0 = {
   11165    { nir_search_value_expression, 0 },
   11166    false,
   11167    nir_op_bfm,
   11168    { &replace218_2_0_0.value, &replace218_2_0_1.value },
   11169    NULL,
   11170 };
   11171 
   11172 #include "compiler/nir/nir_search_helpers.h"
   11173 static const nir_search_variable replace218_2_1 = {
   11174    { nir_search_value_variable, 0 },
   11175    1, /* insert */
   11176    false,
   11177    nir_type_invalid,
   11178    NULL,
   11179 };
   11180 
   11181 #include "compiler/nir/nir_search_helpers.h"
   11182 static const nir_search_variable replace218_2_2 = {
   11183    { nir_search_value_variable, 0 },
   11184    0, /* base */
   11185    false,
   11186    nir_type_invalid,
   11187    NULL,
   11188 };
   11189 #include "compiler/nir/nir_search_helpers.h"
   11190 static const nir_search_expression replace218_2 = {
   11191    { nir_search_value_expression, 0 },
   11192    false,
   11193    nir_op_bfi,
   11194    { &replace218_2_0.value, &replace218_2_1.value, &replace218_2_2.value },
   11195    NULL,
   11196 };
   11197 #include "compiler/nir/nir_search_helpers.h"
   11198 static const nir_search_expression replace218 = {
   11199    { nir_search_value_expression, 0 },
   11200    false,
   11201    nir_op_bcsel,
   11202    { &replace218_0.value, &replace218_1.value, &replace218_2.value },
   11203    NULL,
   11204 };
   11205 
   11206 static const struct transform nir_opt_algebraic_bitfield_insert_xforms[] = {
   11207    { &search218, &replace218.value, 25 },
   11208 };
   11209 
   11210 #include "compiler/nir/nir_search_helpers.h"
   11211 static const nir_search_variable search107_0_0 = {
   11212    { nir_search_value_variable, 0 },
   11213    0, /* a */
   11214    false,
   11215    nir_type_invalid,
   11216    NULL,
   11217 };
   11218 #include "compiler/nir/nir_search_helpers.h"
   11219 static const nir_search_expression search107_0 = {
   11220    { nir_search_value_expression, 0 },
   11221    false,
   11222    nir_op_fneg,
   11223    { &search107_0_0.value },
   11224    NULL,
   11225 };
   11226 
   11227 #include "compiler/nir/nir_search_helpers.h"
   11228 static const nir_search_variable search107_1 = {
   11229    { nir_search_value_variable, 0 },
   11230    0, /* a */
   11231    false,
   11232    nir_type_invalid,
   11233    NULL,
   11234 };
   11235 #include "compiler/nir/nir_search_helpers.h"
   11236 static const nir_search_expression search107 = {
   11237    { nir_search_value_expression, 0 },
   11238    false,
   11239    nir_op_feq,
   11240    { &search107_0.value, &search107_1.value },
   11241    NULL,
   11242 };
   11243 
   11244 #include "compiler/nir/nir_search_helpers.h"
   11245 static const nir_search_variable replace107_0 = {
   11246    { nir_search_value_variable, 0 },
   11247    0, /* a */
   11248    false,
   11249    nir_type_invalid,
   11250    NULL,
   11251 };
   11252 
   11253 #include "compiler/nir/nir_search_helpers.h"
   11254 static const nir_search_constant replace107_1 = {
   11255    { nir_search_value_constant, 0 },
   11256    nir_type_float, { 0x0 /* 0.0 */ },
   11257 };
   11258 #include "compiler/nir/nir_search_helpers.h"
   11259 static const nir_search_expression replace107 = {
   11260    { nir_search_value_expression, 0 },
   11261    false,
   11262    nir_op_feq,
   11263    { &replace107_0.value, &replace107_1.value },
   11264    NULL,
   11265 };
   11266 
   11267 #include "compiler/nir/nir_search_helpers.h"
   11268 static const nir_search_variable search246_0_0 = {
   11269    { nir_search_value_variable, 0 },
   11270    0, /* a */
   11271    false,
   11272    nir_type_invalid,
   11273    NULL,
   11274 };
   11275 
   11276 #include "compiler/nir/nir_search_helpers.h"
   11277 static const nir_search_variable search246_0_1 = {
   11278    { nir_search_value_variable, 0 },
   11279    1, /* b */
   11280    true,
   11281    nir_type_invalid,
   11282    NULL,
   11283 };
   11284 
   11285 #include "compiler/nir/nir_search_helpers.h"
   11286 static const nir_search_variable search246_0_2 = {
   11287    { nir_search_value_variable, 0 },
   11288    2, /* c */
   11289    true,
   11290    nir_type_invalid,
   11291    NULL,
   11292 };
   11293 #include "compiler/nir/nir_search_helpers.h"
   11294 static const nir_search_expression search246_0 = {
   11295    { nir_search_value_expression, 0 },
   11296    false,
   11297    nir_op_bcsel,
   11298    { &search246_0_0.value, &search246_0_1.value, &search246_0_2.value },
   11299    NULL,
   11300 };
   11301 
   11302 #include "compiler/nir/nir_search_helpers.h"
   11303 static const nir_search_variable search246_1 = {
   11304    { nir_search_value_variable, 0 },
   11305    3, /* d */
   11306    true,
   11307    nir_type_invalid,
   11308    NULL,
   11309 };
   11310 #include "compiler/nir/nir_search_helpers.h"
   11311 static const nir_search_expression search246 = {
   11312    { nir_search_value_expression, 0 },
   11313    false,
   11314    nir_op_feq,
   11315    { &search246_0.value, &search246_1.value },
   11316    NULL,
   11317 };
   11318 
   11319 #include "compiler/nir/nir_search_helpers.h"
   11320 static const nir_search_variable replace246_0 = {
   11321    { nir_search_value_variable, 0 },
   11322    0, /* a */
   11323    false,
   11324    nir_type_invalid,
   11325    NULL,
   11326 };
   11327 
   11328 #include "compiler/nir/nir_search_helpers.h"
   11329 static const nir_search_variable replace246_1_0 = {
   11330    { nir_search_value_variable, 0 },
   11331    1, /* b */
   11332    false,
   11333    nir_type_invalid,
   11334    NULL,
   11335 };
   11336 
   11337 #include "compiler/nir/nir_search_helpers.h"
   11338 static const nir_search_variable replace246_1_1 = {
   11339    { nir_search_value_variable, 0 },
   11340    3, /* d */
   11341    false,
   11342    nir_type_invalid,
   11343    NULL,
   11344 };
   11345 #include "compiler/nir/nir_search_helpers.h"
   11346 static const nir_search_expression replace246_1 = {
   11347    { nir_search_value_expression, 0 },
   11348    false,
   11349    nir_op_feq,
   11350    { &replace246_1_0.value, &replace246_1_1.value },
   11351    NULL,
   11352 };
   11353 
   11354 #include "compiler/nir/nir_search_helpers.h"
   11355 static const nir_search_variable replace246_2_0 = {
   11356    { nir_search_value_variable, 0 },
   11357    2, /* c */
   11358    false,
   11359    nir_type_invalid,
   11360    NULL,
   11361 };
   11362 
   11363 #include "compiler/nir/nir_search_helpers.h"
   11364 static const nir_search_variable replace246_2_1 = {
   11365    { nir_search_value_variable, 0 },
   11366    3, /* d */
   11367    false,
   11368    nir_type_invalid,
   11369    NULL,
   11370 };
   11371 #include "compiler/nir/nir_search_helpers.h"
   11372 static const nir_search_expression replace246_2 = {
   11373    { nir_search_value_expression, 0 },
   11374    false,
   11375    nir_op_feq,
   11376    { &replace246_2_0.value, &replace246_2_1.value },
   11377    NULL,
   11378 };
   11379 #include "compiler/nir/nir_search_helpers.h"
   11380 static const nir_search_expression replace246 = {
   11381    { nir_search_value_expression, 0 },
   11382    false,
   11383    nir_op_bcsel,
   11384    { &replace246_0.value, &replace246_1.value, &replace246_2.value },
   11385    NULL,
   11386 };
   11387 
   11388 #include "compiler/nir/nir_search_helpers.h"
   11389 static const nir_search_variable search247_0 = {
   11390    { nir_search_value_variable, 0 },
   11391    0, /* d */
   11392    true,
   11393    nir_type_invalid,
   11394    NULL,
   11395 };
   11396 
   11397 #include "compiler/nir/nir_search_helpers.h"
   11398 static const nir_search_variable search247_1_0 = {
   11399    { nir_search_value_variable, 0 },
   11400    1, /* a */
   11401    false,
   11402    nir_type_invalid,
   11403    NULL,
   11404 };
   11405 
   11406 #include "compiler/nir/nir_search_helpers.h"
   11407 static const nir_search_variable search247_1_1 = {
   11408    { nir_search_value_variable, 0 },
   11409    2, /* b */
   11410    true,
   11411    nir_type_invalid,
   11412    NULL,
   11413 };
   11414 
   11415 #include "compiler/nir/nir_search_helpers.h"
   11416 static const nir_search_variable search247_1_2 = {
   11417    { nir_search_value_variable, 0 },
   11418    3, /* c */
   11419    true,
   11420    nir_type_invalid,
   11421    NULL,
   11422 };
   11423 #include "compiler/nir/nir_search_helpers.h"
   11424 static const nir_search_expression search247_1 = {
   11425    { nir_search_value_expression, 0 },
   11426    false,
   11427    nir_op_bcsel,
   11428    { &search247_1_0.value, &search247_1_1.value, &search247_1_2.value },
   11429    NULL,
   11430 };
   11431 #include "compiler/nir/nir_search_helpers.h"
   11432 static const nir_search_expression search247 = {
   11433    { nir_search_value_expression, 0 },
   11434    false,
   11435    nir_op_feq,
   11436    { &search247_0.value, &search247_1.value },
   11437    NULL,
   11438 };
   11439 
   11440 #include "compiler/nir/nir_search_helpers.h"
   11441 static const nir_search_variable replace247_0 = {
   11442    { nir_search_value_variable, 0 },
   11443    1, /* a */
   11444    false,
   11445    nir_type_invalid,
   11446    NULL,
   11447 };
   11448 
   11449 #include "compiler/nir/nir_search_helpers.h"
   11450 static const nir_search_variable replace247_1_0 = {
   11451    { nir_search_value_variable, 0 },
   11452    0, /* d */
   11453    false,
   11454    nir_type_invalid,
   11455    NULL,
   11456 };
   11457 
   11458 #include "compiler/nir/nir_search_helpers.h"
   11459 static const nir_search_variable replace247_1_1 = {
   11460    { nir_search_value_variable, 0 },
   11461    2, /* b */
   11462    false,
   11463    nir_type_invalid,
   11464    NULL,
   11465 };
   11466 #include "compiler/nir/nir_search_helpers.h"
   11467 static const nir_search_expression replace247_1 = {
   11468    { nir_search_value_expression, 0 },
   11469    false,
   11470    nir_op_feq,
   11471    { &replace247_1_0.value, &replace247_1_1.value },
   11472    NULL,
   11473 };
   11474 
   11475 #include "compiler/nir/nir_search_helpers.h"
   11476 static const nir_search_variable replace247_2_0 = {
   11477    { nir_search_value_variable, 0 },
   11478    0, /* d */
   11479    false,
   11480    nir_type_invalid,
   11481    NULL,
   11482 };
   11483 
   11484 #include "compiler/nir/nir_search_helpers.h"
   11485 static const nir_search_variable replace247_2_1 = {
   11486    { nir_search_value_variable, 0 },
   11487    3, /* c */
   11488    false,
   11489    nir_type_invalid,
   11490    NULL,
   11491 };
   11492 #include "compiler/nir/nir_search_helpers.h"
   11493 static const nir_search_expression replace247_2 = {
   11494    { nir_search_value_expression, 0 },
   11495    false,
   11496    nir_op_feq,
   11497    { &replace247_2_0.value, &replace247_2_1.value },
   11498    NULL,
   11499 };
   11500 #include "compiler/nir/nir_search_helpers.h"
   11501 static const nir_search_expression replace247 = {
   11502    { nir_search_value_expression, 0 },
   11503    false,
   11504    nir_op_bcsel,
   11505    { &replace247_0.value, &replace247_1.value, &replace247_2.value },
   11506    NULL,
   11507 };
   11508 
   11509 static const struct transform nir_opt_algebraic_feq_xforms[] = {
   11510    { &search107, &replace107.value, 0 },
   11511    { &search246, &replace246.value, 0 },
   11512    { &search247, &replace247.value, 0 },
   11513 };
   11514 
   11515 #include "compiler/nir/nir_search_helpers.h"
   11516 static const nir_search_variable search42_0 = {
   11517    { nir_search_value_variable, 0 },
   11518    0, /* a */
   11519    false,
   11520    nir_type_invalid,
   11521    NULL,
   11522 };
   11523 
   11524 #include "compiler/nir/nir_search_helpers.h"
   11525 static const nir_search_variable search42_1 = {
   11526    { nir_search_value_variable, 0 },
   11527    1, /* b */
   11528    false,
   11529    nir_type_invalid,
   11530    NULL,
   11531 };
   11532 
   11533 #include "compiler/nir/nir_search_helpers.h"
   11534 static const nir_search_constant search42_2 = {
   11535    { nir_search_value_constant, 0 },
   11536    nir_type_float, { 0x0 /* 0.0 */ },
   11537 };
   11538 #include "compiler/nir/nir_search_helpers.h"
   11539 static const nir_search_expression search42 = {
   11540    { nir_search_value_expression, 0 },
   11541    true,
   11542    nir_op_flrp,
   11543    { &search42_0.value, &search42_1.value, &search42_2.value },
   11544    NULL,
   11545 };
   11546 
   11547 #include "compiler/nir/nir_search_helpers.h"
   11548 static const nir_search_variable replace42 = {
   11549    { nir_search_value_variable, 0 },
   11550    0, /* a */
   11551    false,
   11552    nir_type_invalid,
   11553    NULL,
   11554 };
   11555 
   11556 #include "compiler/nir/nir_search_helpers.h"
   11557 static const nir_search_variable search43_0 = {
   11558    { nir_search_value_variable, 0 },
   11559    0, /* a */
   11560    false,
   11561    nir_type_invalid,
   11562    NULL,
   11563 };
   11564 
   11565 #include "compiler/nir/nir_search_helpers.h"
   11566 static const nir_search_variable search43_1 = {
   11567    { nir_search_value_variable, 0 },
   11568    1, /* b */
   11569    false,
   11570    nir_type_invalid,
   11571    NULL,
   11572 };
   11573 
   11574 #include "compiler/nir/nir_search_helpers.h"
   11575 static const nir_search_constant search43_2 = {
   11576    { nir_search_value_constant, 0 },
   11577    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   11578 };
   11579 #include "compiler/nir/nir_search_helpers.h"
   11580 static const nir_search_expression search43 = {
   11581    { nir_search_value_expression, 0 },
   11582    true,
   11583    nir_op_flrp,
   11584    { &search43_0.value, &search43_1.value, &search43_2.value },
   11585    NULL,
   11586 };
   11587 
   11588 #include "compiler/nir/nir_search_helpers.h"
   11589 static const nir_search_variable replace43 = {
   11590    { nir_search_value_variable, 0 },
   11591    1, /* b */
   11592    false,
   11593    nir_type_invalid,
   11594    NULL,
   11595 };
   11596 
   11597 #include "compiler/nir/nir_search_helpers.h"
   11598 static const nir_search_variable search44_0 = {
   11599    { nir_search_value_variable, 0 },
   11600    0, /* a */
   11601    false,
   11602    nir_type_invalid,
   11603    NULL,
   11604 };
   11605 
   11606 #include "compiler/nir/nir_search_helpers.h"
   11607 static const nir_search_variable search44_1 = {
   11608    { nir_search_value_variable, 0 },
   11609    0, /* a */
   11610    false,
   11611    nir_type_invalid,
   11612    NULL,
   11613 };
   11614 
   11615 #include "compiler/nir/nir_search_helpers.h"
   11616 static const nir_search_variable search44_2 = {
   11617    { nir_search_value_variable, 0 },
   11618    1, /* b */
   11619    false,
   11620    nir_type_invalid,
   11621    NULL,
   11622 };
   11623 #include "compiler/nir/nir_search_helpers.h"
   11624 static const nir_search_expression search44 = {
   11625    { nir_search_value_expression, 0 },
   11626    true,
   11627    nir_op_flrp,
   11628    { &search44_0.value, &search44_1.value, &search44_2.value },
   11629    NULL,
   11630 };
   11631 
   11632 #include "compiler/nir/nir_search_helpers.h"
   11633 static const nir_search_variable replace44 = {
   11634    { nir_search_value_variable, 0 },
   11635    0, /* a */
   11636    false,
   11637    nir_type_invalid,
   11638    NULL,
   11639 };
   11640 
   11641 #include "compiler/nir/nir_search_helpers.h"
   11642 static const nir_search_constant search45_0 = {
   11643    { nir_search_value_constant, 0 },
   11644    nir_type_float, { 0x0 /* 0.0 */ },
   11645 };
   11646 
   11647 #include "compiler/nir/nir_search_helpers.h"
   11648 static const nir_search_variable search45_1 = {
   11649    { nir_search_value_variable, 0 },
   11650    0, /* a */
   11651    false,
   11652    nir_type_invalid,
   11653    NULL,
   11654 };
   11655 
   11656 #include "compiler/nir/nir_search_helpers.h"
   11657 static const nir_search_variable search45_2 = {
   11658    { nir_search_value_variable, 0 },
   11659    1, /* b */
   11660    false,
   11661    nir_type_invalid,
   11662    NULL,
   11663 };
   11664 #include "compiler/nir/nir_search_helpers.h"
   11665 static const nir_search_expression search45 = {
   11666    { nir_search_value_expression, 0 },
   11667    true,
   11668    nir_op_flrp,
   11669    { &search45_0.value, &search45_1.value, &search45_2.value },
   11670    NULL,
   11671 };
   11672 
   11673 #include "compiler/nir/nir_search_helpers.h"
   11674 static const nir_search_variable replace45_0 = {
   11675    { nir_search_value_variable, 0 },
   11676    0, /* a */
   11677    false,
   11678    nir_type_invalid,
   11679    NULL,
   11680 };
   11681 
   11682 #include "compiler/nir/nir_search_helpers.h"
   11683 static const nir_search_variable replace45_1 = {
   11684    { nir_search_value_variable, 0 },
   11685    1, /* b */
   11686    false,
   11687    nir_type_invalid,
   11688    NULL,
   11689 };
   11690 #include "compiler/nir/nir_search_helpers.h"
   11691 static const nir_search_expression replace45 = {
   11692    { nir_search_value_expression, 0 },
   11693    false,
   11694    nir_op_fmul,
   11695    { &replace45_0.value, &replace45_1.value },
   11696    NULL,
   11697 };
   11698 
   11699 #include "compiler/nir/nir_search_helpers.h"
   11700 static const nir_search_variable search46_0 = {
   11701    { nir_search_value_variable, 0 },
   11702    0, /* a */
   11703    false,
   11704    nir_type_invalid,
   11705    NULL,
   11706 };
   11707 
   11708 #include "compiler/nir/nir_search_helpers.h"
   11709 static const nir_search_variable search46_1 = {
   11710    { nir_search_value_variable, 0 },
   11711    1, /* b */
   11712    false,
   11713    nir_type_invalid,
   11714    NULL,
   11715 };
   11716 
   11717 #include "compiler/nir/nir_search_helpers.h"
   11718 static const nir_search_variable search46_2_0 = {
   11719    { nir_search_value_variable, 0 },
   11720    2, /* c */
   11721    false,
   11722    nir_type_invalid,
   11723    NULL,
   11724 };
   11725 #include "compiler/nir/nir_search_helpers.h"
   11726 static const nir_search_expression search46_2 = {
   11727    { nir_search_value_expression, 0 },
   11728    false,
   11729    nir_op_b2f,
   11730    { &search46_2_0.value },
   11731    NULL,
   11732 };
   11733 #include "compiler/nir/nir_search_helpers.h"
   11734 static const nir_search_expression search46 = {
   11735    { nir_search_value_expression, 0 },
   11736    true,
   11737    nir_op_flrp,
   11738    { &search46_0.value, &search46_1.value, &search46_2.value },
   11739    NULL,
   11740 };
   11741 
   11742 #include "compiler/nir/nir_search_helpers.h"
   11743 static const nir_search_variable replace46_0 = {
   11744    { nir_search_value_variable, 0 },
   11745    2, /* c */
   11746    false,
   11747    nir_type_invalid,
   11748    NULL,
   11749 };
   11750 
   11751 #include "compiler/nir/nir_search_helpers.h"
   11752 static const nir_search_variable replace46_1 = {
   11753    { nir_search_value_variable, 0 },
   11754    1, /* b */
   11755    false,
   11756    nir_type_invalid,
   11757    NULL,
   11758 };
   11759 
   11760 #include "compiler/nir/nir_search_helpers.h"
   11761 static const nir_search_variable replace46_2 = {
   11762    { nir_search_value_variable, 0 },
   11763    0, /* a */
   11764    false,
   11765    nir_type_invalid,
   11766    NULL,
   11767 };
   11768 #include "compiler/nir/nir_search_helpers.h"
   11769 static const nir_search_expression replace46 = {
   11770    { nir_search_value_expression, 0 },
   11771    false,
   11772    nir_op_bcsel,
   11773    { &replace46_0.value, &replace46_1.value, &replace46_2.value },
   11774    NULL,
   11775 };
   11776 
   11777 #include "compiler/nir/nir_search_helpers.h"
   11778 static const nir_search_variable search47_0 = {
   11779    { nir_search_value_variable, 0 },
   11780    0, /* a */
   11781    false,
   11782    nir_type_invalid,
   11783    NULL,
   11784 };
   11785 
   11786 #include "compiler/nir/nir_search_helpers.h"
   11787 static const nir_search_constant search47_1 = {
   11788    { nir_search_value_constant, 0 },
   11789    nir_type_float, { 0x0 /* 0.0 */ },
   11790 };
   11791 
   11792 #include "compiler/nir/nir_search_helpers.h"
   11793 static const nir_search_variable search47_2 = {
   11794    { nir_search_value_variable, 0 },
   11795    1, /* c */
   11796    false,
   11797    nir_type_invalid,
   11798    NULL,
   11799 };
   11800 #include "compiler/nir/nir_search_helpers.h"
   11801 static const nir_search_expression search47 = {
   11802    { nir_search_value_expression, 0 },
   11803    true,
   11804    nir_op_flrp,
   11805    { &search47_0.value, &search47_1.value, &search47_2.value },
   11806    NULL,
   11807 };
   11808 
   11809 #include "compiler/nir/nir_search_helpers.h"
   11810 static const nir_search_variable replace47_0_0_0 = {
   11811    { nir_search_value_variable, 0 },
   11812    0, /* a */
   11813    false,
   11814    nir_type_invalid,
   11815    NULL,
   11816 };
   11817 #include "compiler/nir/nir_search_helpers.h"
   11818 static const nir_search_expression replace47_0_0 = {
   11819    { nir_search_value_expression, 0 },
   11820    false,
   11821    nir_op_fneg,
   11822    { &replace47_0_0_0.value },
   11823    NULL,
   11824 };
   11825 
   11826 #include "compiler/nir/nir_search_helpers.h"
   11827 static const nir_search_variable replace47_0_1 = {
   11828    { nir_search_value_variable, 0 },
   11829    1, /* c */
   11830    false,
   11831    nir_type_invalid,
   11832    NULL,
   11833 };
   11834 #include "compiler/nir/nir_search_helpers.h"
   11835 static const nir_search_expression replace47_0 = {
   11836    { nir_search_value_expression, 0 },
   11837    false,
   11838    nir_op_fmul,
   11839    { &replace47_0_0.value, &replace47_0_1.value },
   11840    NULL,
   11841 };
   11842 
   11843 #include "compiler/nir/nir_search_helpers.h"
   11844 static const nir_search_variable replace47_1 = {
   11845    { nir_search_value_variable, 0 },
   11846    0, /* a */
   11847    false,
   11848    nir_type_invalid,
   11849    NULL,
   11850 };
   11851 #include "compiler/nir/nir_search_helpers.h"
   11852 static const nir_search_expression replace47 = {
   11853    { nir_search_value_expression, 0 },
   11854    false,
   11855    nir_op_fadd,
   11856    { &replace47_0.value, &replace47_1.value },
   11857    NULL,
   11858 };
   11859 
   11860 #include "compiler/nir/nir_search_helpers.h"
   11861 static const nir_search_variable search48_0 = {
   11862    { nir_search_value_variable, 0 },
   11863    0, /* a */
   11864    false,
   11865    nir_type_invalid,
   11866    NULL,
   11867 };
   11868 
   11869 #include "compiler/nir/nir_search_helpers.h"
   11870 static const nir_search_variable search48_1 = {
   11871    { nir_search_value_variable, 0 },
   11872    1, /* b */
   11873    false,
   11874    nir_type_invalid,
   11875    NULL,
   11876 };
   11877 
   11878 #include "compiler/nir/nir_search_helpers.h"
   11879 static const nir_search_variable search48_2 = {
   11880    { nir_search_value_variable, 0 },
   11881    2, /* c */
   11882    false,
   11883    nir_type_invalid,
   11884    NULL,
   11885 };
   11886 #include "compiler/nir/nir_search_helpers.h"
   11887 static const nir_search_expression search48 = {
   11888    { nir_search_value_expression, 32 },
   11889    false,
   11890    nir_op_flrp,
   11891    { &search48_0.value, &search48_1.value, &search48_2.value },
   11892    NULL,
   11893 };
   11894 
   11895 #include "compiler/nir/nir_search_helpers.h"
   11896 static const nir_search_variable replace48_0_0 = {
   11897    { nir_search_value_variable, 0 },
   11898    2, /* c */
   11899    false,
   11900    nir_type_invalid,
   11901    NULL,
   11902 };
   11903 
   11904 #include "compiler/nir/nir_search_helpers.h"
   11905 static const nir_search_variable replace48_0_1_0 = {
   11906    { nir_search_value_variable, 0 },
   11907    1, /* b */
   11908    false,
   11909    nir_type_invalid,
   11910    NULL,
   11911 };
   11912 
   11913 #include "compiler/nir/nir_search_helpers.h"
   11914 static const nir_search_variable replace48_0_1_1 = {
   11915    { nir_search_value_variable, 0 },
   11916    0, /* a */
   11917    false,
   11918    nir_type_invalid,
   11919    NULL,
   11920 };
   11921 #include "compiler/nir/nir_search_helpers.h"
   11922 static const nir_search_expression replace48_0_1 = {
   11923    { nir_search_value_expression, 0 },
   11924    false,
   11925    nir_op_fsub,
   11926    { &replace48_0_1_0.value, &replace48_0_1_1.value },
   11927    NULL,
   11928 };
   11929 #include "compiler/nir/nir_search_helpers.h"
   11930 static const nir_search_expression replace48_0 = {
   11931    { nir_search_value_expression, 0 },
   11932    false,
   11933    nir_op_fmul,
   11934    { &replace48_0_0.value, &replace48_0_1.value },
   11935    NULL,
   11936 };
   11937 
   11938 #include "compiler/nir/nir_search_helpers.h"
   11939 static const nir_search_variable replace48_1 = {
   11940    { nir_search_value_variable, 0 },
   11941    0, /* a */
   11942    false,
   11943    nir_type_invalid,
   11944    NULL,
   11945 };
   11946 #include "compiler/nir/nir_search_helpers.h"
   11947 static const nir_search_expression replace48 = {
   11948    { nir_search_value_expression, 0 },
   11949    false,
   11950    nir_op_fadd,
   11951    { &replace48_0.value, &replace48_1.value },
   11952    NULL,
   11953 };
   11954 
   11955 #include "compiler/nir/nir_search_helpers.h"
   11956 static const nir_search_variable search49_0 = {
   11957    { nir_search_value_variable, 0 },
   11958    0, /* a */
   11959    false,
   11960    nir_type_invalid,
   11961    NULL,
   11962 };
   11963 
   11964 #include "compiler/nir/nir_search_helpers.h"
   11965 static const nir_search_variable search49_1 = {
   11966    { nir_search_value_variable, 0 },
   11967    1, /* b */
   11968    false,
   11969    nir_type_invalid,
   11970    NULL,
   11971 };
   11972 
   11973 #include "compiler/nir/nir_search_helpers.h"
   11974 static const nir_search_variable search49_2 = {
   11975    { nir_search_value_variable, 0 },
   11976    2, /* c */
   11977    false,
   11978    nir_type_invalid,
   11979    NULL,
   11980 };
   11981 #include "compiler/nir/nir_search_helpers.h"
   11982 static const nir_search_expression search49 = {
   11983    { nir_search_value_expression, 64 },
   11984    false,
   11985    nir_op_flrp,
   11986    { &search49_0.value, &search49_1.value, &search49_2.value },
   11987    NULL,
   11988 };
   11989 
   11990 #include "compiler/nir/nir_search_helpers.h"
   11991 static const nir_search_variable replace49_0_0 = {
   11992    { nir_search_value_variable, 0 },
   11993    2, /* c */
   11994    false,
   11995    nir_type_invalid,
   11996    NULL,
   11997 };
   11998 
   11999 #include "compiler/nir/nir_search_helpers.h"
   12000 static const nir_search_variable replace49_0_1_0 = {
   12001    { nir_search_value_variable, 0 },
   12002    1, /* b */
   12003    false,
   12004    nir_type_invalid,
   12005    NULL,
   12006 };
   12007 
   12008 #include "compiler/nir/nir_search_helpers.h"
   12009 static const nir_search_variable replace49_0_1_1 = {
   12010    { nir_search_value_variable, 0 },
   12011    0, /* a */
   12012    false,
   12013    nir_type_invalid,
   12014    NULL,
   12015 };
   12016 #include "compiler/nir/nir_search_helpers.h"
   12017 static const nir_search_expression replace49_0_1 = {
   12018    { nir_search_value_expression, 0 },
   12019    false,
   12020    nir_op_fsub,
   12021    { &replace49_0_1_0.value, &replace49_0_1_1.value },
   12022    NULL,
   12023 };
   12024 #include "compiler/nir/nir_search_helpers.h"
   12025 static const nir_search_expression replace49_0 = {
   12026    { nir_search_value_expression, 0 },
   12027    false,
   12028    nir_op_fmul,
   12029    { &replace49_0_0.value, &replace49_0_1.value },
   12030    NULL,
   12031 };
   12032 
   12033 #include "compiler/nir/nir_search_helpers.h"
   12034 static const nir_search_variable replace49_1 = {
   12035    { nir_search_value_variable, 0 },
   12036    0, /* a */
   12037    false,
   12038    nir_type_invalid,
   12039    NULL,
   12040 };
   12041 #include "compiler/nir/nir_search_helpers.h"
   12042 static const nir_search_expression replace49 = {
   12043    { nir_search_value_expression, 0 },
   12044    false,
   12045    nir_op_fadd,
   12046    { &replace49_0.value, &replace49_1.value },
   12047    NULL,
   12048 };
   12049 
   12050 static const struct transform nir_opt_algebraic_flrp_xforms[] = {
   12051    { &search42, &replace42.value, 0 },
   12052    { &search43, &replace43.value, 0 },
   12053    { &search44, &replace44.value, 0 },
   12054    { &search45, &replace45.value, 0 },
   12055    { &search46, &replace46.value, 2 },
   12056    { &search47, &replace47.value, 0 },
   12057    { &search48, &replace48.value, 2 },
   12058    { &search49, &replace49.value, 3 },
   12059 };
   12060 
   12061 #include "compiler/nir/nir_search_helpers.h"
   12062 static const nir_search_variable search94_0_0 = {
   12063    { nir_search_value_variable, 0 },
   12064    0, /* a */
   12065    false,
   12066    nir_type_invalid,
   12067    NULL,
   12068 };
   12069 
   12070 #include "compiler/nir/nir_search_helpers.h"
   12071 static const nir_search_variable search94_0_1 = {
   12072    { nir_search_value_variable, 0 },
   12073    1, /* b */
   12074    false,
   12075    nir_type_invalid,
   12076    NULL,
   12077 };
   12078 #include "compiler/nir/nir_search_helpers.h"
   12079 static const nir_search_expression search94_0 = {
   12080    { nir_search_value_expression, 0 },
   12081    false,
   12082    nir_op_flt,
   12083    { &search94_0_0.value, &search94_0_1.value },
   12084    NULL,
   12085 };
   12086 
   12087 #include "compiler/nir/nir_search_helpers.h"
   12088 static const nir_search_variable search94_1_0 = {
   12089    { nir_search_value_variable, 0 },
   12090    0, /* a */
   12091    false,
   12092    nir_type_invalid,
   12093    NULL,
   12094 };
   12095 
   12096 #include "compiler/nir/nir_search_helpers.h"
   12097 static const nir_search_variable search94_1_1 = {
   12098    { nir_search_value_variable, 0 },
   12099    2, /* c */
   12100    false,
   12101    nir_type_invalid,
   12102    NULL,
   12103 };
   12104 #include "compiler/nir/nir_search_helpers.h"
   12105 static const nir_search_expression search94_1 = {
   12106    { nir_search_value_expression, 0 },
   12107    false,
   12108    nir_op_flt,
   12109    { &search94_1_0.value, &search94_1_1.value },
   12110    NULL,
   12111 };
   12112 #include "compiler/nir/nir_search_helpers.h"
   12113 static const nir_search_expression search94 = {
   12114    { nir_search_value_expression, 0 },
   12115    true,
   12116    nir_op_ior,
   12117    { &search94_0.value, &search94_1.value },
   12118    NULL,
   12119 };
   12120 
   12121 #include "compiler/nir/nir_search_helpers.h"
   12122 static const nir_search_variable replace94_0 = {
   12123    { nir_search_value_variable, 0 },
   12124    0, /* a */
   12125    false,
   12126    nir_type_invalid,
   12127    NULL,
   12128 };
   12129 
   12130 #include "compiler/nir/nir_search_helpers.h"
   12131 static const nir_search_variable replace94_1_0 = {
   12132    { nir_search_value_variable, 0 },
   12133    1, /* b */
   12134    false,
   12135    nir_type_invalid,
   12136    NULL,
   12137 };
   12138 
   12139 #include "compiler/nir/nir_search_helpers.h"
   12140 static const nir_search_variable replace94_1_1 = {
   12141    { nir_search_value_variable, 0 },
   12142    2, /* c */
   12143    false,
   12144    nir_type_invalid,
   12145    NULL,
   12146 };
   12147 #include "compiler/nir/nir_search_helpers.h"
   12148 static const nir_search_expression replace94_1 = {
   12149    { nir_search_value_expression, 0 },
   12150    false,
   12151    nir_op_fmax,
   12152    { &replace94_1_0.value, &replace94_1_1.value },
   12153    NULL,
   12154 };
   12155 #include "compiler/nir/nir_search_helpers.h"
   12156 static const nir_search_expression replace94 = {
   12157    { nir_search_value_expression, 0 },
   12158    false,
   12159    nir_op_flt,
   12160    { &replace94_0.value, &replace94_1.value },
   12161    NULL,
   12162 };
   12163 
   12164 #include "compiler/nir/nir_search_helpers.h"
   12165 static const nir_search_variable search95_0_0 = {
   12166    { nir_search_value_variable, 0 },
   12167    0, /* a */
   12168    false,
   12169    nir_type_invalid,
   12170    NULL,
   12171 };
   12172 
   12173 #include "compiler/nir/nir_search_helpers.h"
   12174 static const nir_search_variable search95_0_1 = {
   12175    { nir_search_value_variable, 0 },
   12176    1, /* c */
   12177    false,
   12178    nir_type_invalid,
   12179    NULL,
   12180 };
   12181 #include "compiler/nir/nir_search_helpers.h"
   12182 static const nir_search_expression search95_0 = {
   12183    { nir_search_value_expression, 0 },
   12184    false,
   12185    nir_op_flt,
   12186    { &search95_0_0.value, &search95_0_1.value },
   12187    NULL,
   12188 };
   12189 
   12190 #include "compiler/nir/nir_search_helpers.h"
   12191 static const nir_search_variable search95_1_0 = {
   12192    { nir_search_value_variable, 0 },
   12193    2, /* b */
   12194    false,
   12195    nir_type_invalid,
   12196    NULL,
   12197 };
   12198 
   12199 #include "compiler/nir/nir_search_helpers.h"
   12200 static const nir_search_variable search95_1_1 = {
   12201    { nir_search_value_variable, 0 },
   12202    1, /* c */
   12203    false,
   12204    nir_type_invalid,
   12205    NULL,
   12206 };
   12207 #include "compiler/nir/nir_search_helpers.h"
   12208 static const nir_search_expression search95_1 = {
   12209    { nir_search_value_expression, 0 },
   12210    false,
   12211    nir_op_flt,
   12212    { &search95_1_0.value, &search95_1_1.value },
   12213    NULL,
   12214 };
   12215 #include "compiler/nir/nir_search_helpers.h"
   12216 static const nir_search_expression search95 = {
   12217    { nir_search_value_expression, 0 },
   12218    true,
   12219    nir_op_ior,
   12220    { &search95_0.value, &search95_1.value },
   12221    NULL,
   12222 };
   12223 
   12224 #include "compiler/nir/nir_search_helpers.h"
   12225 static const nir_search_variable replace95_0_0 = {
   12226    { nir_search_value_variable, 0 },
   12227    0, /* a */
   12228    false,
   12229    nir_type_invalid,
   12230    NULL,
   12231 };
   12232 
   12233 #include "compiler/nir/nir_search_helpers.h"
   12234 static const nir_search_variable replace95_0_1 = {
   12235    { nir_search_value_variable, 0 },
   12236    2, /* b */
   12237    false,
   12238    nir_type_invalid,
   12239    NULL,
   12240 };
   12241 #include "compiler/nir/nir_search_helpers.h"
   12242 static const nir_search_expression replace95_0 = {
   12243    { nir_search_value_expression, 0 },
   12244    false,
   12245    nir_op_fmin,
   12246    { &replace95_0_0.value, &replace95_0_1.value },
   12247    NULL,
   12248 };
   12249 
   12250 #include "compiler/nir/nir_search_helpers.h"
   12251 static const nir_search_variable replace95_1 = {
   12252    { nir_search_value_variable, 0 },
   12253    1, /* c */
   12254    false,
   12255    nir_type_invalid,
   12256    NULL,
   12257 };
   12258 #include "compiler/nir/nir_search_helpers.h"
   12259 static const nir_search_expression replace95 = {
   12260    { nir_search_value_expression, 0 },
   12261    false,
   12262    nir_op_flt,
   12263    { &replace95_0.value, &replace95_1.value },
   12264    NULL,
   12265 };
   12266 
   12267 #include "compiler/nir/nir_search_helpers.h"
   12268 static const nir_search_variable search96_0_0 = {
   12269    { nir_search_value_variable, 0 },
   12270    0, /* a */
   12271    false,
   12272    nir_type_invalid,
   12273    NULL,
   12274 };
   12275 
   12276 #include "compiler/nir/nir_search_helpers.h"
   12277 static const nir_search_variable search96_0_1 = {
   12278    { nir_search_value_variable, 0 },
   12279    1, /* b */
   12280    false,
   12281    nir_type_invalid,
   12282    NULL,
   12283 };
   12284 #include "compiler/nir/nir_search_helpers.h"
   12285 static const nir_search_expression search96_0 = {
   12286    { nir_search_value_expression, 0 },
   12287    false,
   12288    nir_op_fge,
   12289    { &search96_0_0.value, &search96_0_1.value },
   12290    NULL,
   12291 };
   12292 
   12293 #include "compiler/nir/nir_search_helpers.h"
   12294 static const nir_search_variable search96_1_0 = {
   12295    { nir_search_value_variable, 0 },
   12296    0, /* a */
   12297    false,
   12298    nir_type_invalid,
   12299    NULL,
   12300 };
   12301 
   12302 #include "compiler/nir/nir_search_helpers.h"
   12303 static const nir_search_variable search96_1_1 = {
   12304    { nir_search_value_variable, 0 },
   12305    2, /* c */
   12306    false,
   12307    nir_type_invalid,
   12308    NULL,
   12309 };
   12310 #include "compiler/nir/nir_search_helpers.h"
   12311 static const nir_search_expression search96_1 = {
   12312    { nir_search_value_expression, 0 },
   12313    false,
   12314    nir_op_fge,
   12315    { &search96_1_0.value, &search96_1_1.value },
   12316    NULL,
   12317 };
   12318 #include "compiler/nir/nir_search_helpers.h"
   12319 static const nir_search_expression search96 = {
   12320    { nir_search_value_expression, 0 },
   12321    true,
   12322    nir_op_ior,
   12323    { &search96_0.value, &search96_1.value },
   12324    NULL,
   12325 };
   12326 
   12327 #include "compiler/nir/nir_search_helpers.h"
   12328 static const nir_search_variable replace96_0 = {
   12329    { nir_search_value_variable, 0 },
   12330    0, /* a */
   12331    false,
   12332    nir_type_invalid,
   12333    NULL,
   12334 };
   12335 
   12336 #include "compiler/nir/nir_search_helpers.h"
   12337 static const nir_search_variable replace96_1_0 = {
   12338    { nir_search_value_variable, 0 },
   12339    1, /* b */
   12340    false,
   12341    nir_type_invalid,
   12342    NULL,
   12343 };
   12344 
   12345 #include "compiler/nir/nir_search_helpers.h"
   12346 static const nir_search_variable replace96_1_1 = {
   12347    { nir_search_value_variable, 0 },
   12348    2, /* c */
   12349    false,
   12350    nir_type_invalid,
   12351    NULL,
   12352 };
   12353 #include "compiler/nir/nir_search_helpers.h"
   12354 static const nir_search_expression replace96_1 = {
   12355    { nir_search_value_expression, 0 },
   12356    false,
   12357    nir_op_fmin,
   12358    { &replace96_1_0.value, &replace96_1_1.value },
   12359    NULL,
   12360 };
   12361 #include "compiler/nir/nir_search_helpers.h"
   12362 static const nir_search_expression replace96 = {
   12363    { nir_search_value_expression, 0 },
   12364    false,
   12365    nir_op_fge,
   12366    { &replace96_0.value, &replace96_1.value },
   12367    NULL,
   12368 };
   12369 
   12370 #include "compiler/nir/nir_search_helpers.h"
   12371 static const nir_search_variable search97_0_0 = {
   12372    { nir_search_value_variable, 0 },
   12373    0, /* a */
   12374    false,
   12375    nir_type_invalid,
   12376    NULL,
   12377 };
   12378 
   12379 #include "compiler/nir/nir_search_helpers.h"
   12380 static const nir_search_variable search97_0_1 = {
   12381    { nir_search_value_variable, 0 },
   12382    1, /* c */
   12383    false,
   12384    nir_type_invalid,
   12385    NULL,
   12386 };
   12387 #include "compiler/nir/nir_search_helpers.h"
   12388 static const nir_search_expression search97_0 = {
   12389    { nir_search_value_expression, 0 },
   12390    false,
   12391    nir_op_fge,
   12392    { &search97_0_0.value, &search97_0_1.value },
   12393    NULL,
   12394 };
   12395 
   12396 #include "compiler/nir/nir_search_helpers.h"
   12397 static const nir_search_variable search97_1_0 = {
   12398    { nir_search_value_variable, 0 },
   12399    2, /* b */
   12400    false,
   12401    nir_type_invalid,
   12402    NULL,
   12403 };
   12404 
   12405 #include "compiler/nir/nir_search_helpers.h"
   12406 static const nir_search_variable search97_1_1 = {
   12407    { nir_search_value_variable, 0 },
   12408    1, /* c */
   12409    false,
   12410    nir_type_invalid,
   12411    NULL,
   12412 };
   12413 #include "compiler/nir/nir_search_helpers.h"
   12414 static const nir_search_expression search97_1 = {
   12415    { nir_search_value_expression, 0 },
   12416    false,
   12417    nir_op_fge,
   12418    { &search97_1_0.value, &search97_1_1.value },
   12419    NULL,
   12420 };
   12421 #include "compiler/nir/nir_search_helpers.h"
   12422 static const nir_search_expression search97 = {
   12423    { nir_search_value_expression, 0 },
   12424    true,
   12425    nir_op_ior,
   12426    { &search97_0.value, &search97_1.value },
   12427    NULL,
   12428 };
   12429 
   12430 #include "compiler/nir/nir_search_helpers.h"
   12431 static const nir_search_variable replace97_0_0 = {
   12432    { nir_search_value_variable, 0 },
   12433    0, /* a */
   12434    false,
   12435    nir_type_invalid,
   12436    NULL,
   12437 };
   12438 
   12439 #include "compiler/nir/nir_search_helpers.h"
   12440 static const nir_search_variable replace97_0_1 = {
   12441    { nir_search_value_variable, 0 },
   12442    2, /* b */
   12443    false,
   12444    nir_type_invalid,
   12445    NULL,
   12446 };
   12447 #include "compiler/nir/nir_search_helpers.h"
   12448 static const nir_search_expression replace97_0 = {
   12449    { nir_search_value_expression, 0 },
   12450    false,
   12451    nir_op_fmax,
   12452    { &replace97_0_0.value, &replace97_0_1.value },
   12453    NULL,
   12454 };
   12455 
   12456 #include "compiler/nir/nir_search_helpers.h"
   12457 static const nir_search_variable replace97_1 = {
   12458    { nir_search_value_variable, 0 },
   12459    1, /* c */
   12460    false,
   12461    nir_type_invalid,
   12462    NULL,
   12463 };
   12464 #include "compiler/nir/nir_search_helpers.h"
   12465 static const nir_search_expression replace97 = {
   12466    { nir_search_value_expression, 0 },
   12467    false,
   12468    nir_op_fge,
   12469    { &replace97_0.value, &replace97_1.value },
   12470    NULL,
   12471 };
   12472 
   12473 #include "compiler/nir/nir_search_helpers.h"
   12474 static const nir_search_variable search125_0 = {
   12475    { nir_search_value_variable, 0 },
   12476    0, /* a */
   12477    false,
   12478    nir_type_invalid,
   12479    NULL,
   12480 };
   12481 
   12482 #include "compiler/nir/nir_search_helpers.h"
   12483 static const nir_search_variable search125_1 = {
   12484    { nir_search_value_variable, 0 },
   12485    0, /* a */
   12486    false,
   12487    nir_type_invalid,
   12488    NULL,
   12489 };
   12490 #include "compiler/nir/nir_search_helpers.h"
   12491 static const nir_search_expression search125 = {
   12492    { nir_search_value_expression, 0 },
   12493    false,
   12494    nir_op_ior,
   12495    { &search125_0.value, &search125_1.value },
   12496    NULL,
   12497 };
   12498 
   12499 #include "compiler/nir/nir_search_helpers.h"
   12500 static const nir_search_variable replace125 = {
   12501    { nir_search_value_variable, 0 },
   12502    0, /* a */
   12503    false,
   12504    nir_type_invalid,
   12505    NULL,
   12506 };
   12507 
   12508 #include "compiler/nir/nir_search_helpers.h"
   12509 static const nir_search_variable search126_0 = {
   12510    { nir_search_value_variable, 0 },
   12511    0, /* a */
   12512    false,
   12513    nir_type_invalid,
   12514    NULL,
   12515 };
   12516 
   12517 #include "compiler/nir/nir_search_helpers.h"
   12518 static const nir_search_constant search126_1 = {
   12519    { nir_search_value_constant, 0 },
   12520    nir_type_int, { 0x0 /* 0 */ },
   12521 };
   12522 #include "compiler/nir/nir_search_helpers.h"
   12523 static const nir_search_expression search126 = {
   12524    { nir_search_value_expression, 0 },
   12525    false,
   12526    nir_op_ior,
   12527    { &search126_0.value, &search126_1.value },
   12528    NULL,
   12529 };
   12530 
   12531 #include "compiler/nir/nir_search_helpers.h"
   12532 static const nir_search_variable replace126 = {
   12533    { nir_search_value_variable, 0 },
   12534    0, /* a */
   12535    false,
   12536    nir_type_invalid,
   12537    NULL,
   12538 };
   12539 
   12540 #include "compiler/nir/nir_search_helpers.h"
   12541 static const nir_search_variable search127_0 = {
   12542    { nir_search_value_variable, 0 },
   12543    0, /* a */
   12544    false,
   12545    nir_type_invalid,
   12546    NULL,
   12547 };
   12548 
   12549 #include "compiler/nir/nir_search_helpers.h"
   12550 static const nir_search_constant search127_1 = {
   12551    { nir_search_value_constant, 32 },
   12552    nir_type_bool32, { NIR_TRUE /* True */ },
   12553 };
   12554 #include "compiler/nir/nir_search_helpers.h"
   12555 static const nir_search_expression search127 = {
   12556    { nir_search_value_expression, 0 },
   12557    false,
   12558    nir_op_ior,
   12559    { &search127_0.value, &search127_1.value },
   12560    NULL,
   12561 };
   12562 
   12563 #include "compiler/nir/nir_search_helpers.h"
   12564 static const nir_search_constant replace127 = {
   12565    { nir_search_value_constant, 32 },
   12566    nir_type_bool32, { NIR_TRUE /* True */ },
   12567 };
   12568 
   12569 #include "compiler/nir/nir_search_helpers.h"
   12570 static const nir_search_variable search133_0_0 = {
   12571    { nir_search_value_variable, 0 },
   12572    0, /* a */
   12573    false,
   12574    nir_type_invalid,
   12575    NULL,
   12576 };
   12577 #include "compiler/nir/nir_search_helpers.h"
   12578 static const nir_search_expression search133_0 = {
   12579    { nir_search_value_expression, 0 },
   12580    false,
   12581    nir_op_inot,
   12582    { &search133_0_0.value },
   12583    NULL,
   12584 };
   12585 
   12586 #include "compiler/nir/nir_search_helpers.h"
   12587 static const nir_search_variable search133_1_0 = {
   12588    { nir_search_value_variable, 0 },
   12589    1, /* b */
   12590    false,
   12591    nir_type_invalid,
   12592    NULL,
   12593 };
   12594 #include "compiler/nir/nir_search_helpers.h"
   12595 static const nir_search_expression search133_1 = {
   12596    { nir_search_value_expression, 0 },
   12597    false,
   12598    nir_op_inot,
   12599    { &search133_1_0.value },
   12600    NULL,
   12601 };
   12602 #include "compiler/nir/nir_search_helpers.h"
   12603 static const nir_search_expression search133 = {
   12604    { nir_search_value_expression, 0 },
   12605    false,
   12606    nir_op_ior,
   12607    { &search133_0.value, &search133_1.value },
   12608    NULL,
   12609 };
   12610 
   12611 #include "compiler/nir/nir_search_helpers.h"
   12612 static const nir_search_variable replace133_0_0 = {
   12613    { nir_search_value_variable, 0 },
   12614    0, /* a */
   12615    false,
   12616    nir_type_invalid,
   12617    NULL,
   12618 };
   12619 
   12620 #include "compiler/nir/nir_search_helpers.h"
   12621 static const nir_search_variable replace133_0_1 = {
   12622    { nir_search_value_variable, 0 },
   12623    1, /* b */
   12624    false,
   12625    nir_type_invalid,
   12626    NULL,
   12627 };
   12628 #include "compiler/nir/nir_search_helpers.h"
   12629 static const nir_search_expression replace133_0 = {
   12630    { nir_search_value_expression, 0 },
   12631    false,
   12632    nir_op_iand,
   12633    { &replace133_0_0.value, &replace133_0_1.value },
   12634    NULL,
   12635 };
   12636 #include "compiler/nir/nir_search_helpers.h"
   12637 static const nir_search_expression replace133 = {
   12638    { nir_search_value_expression, 0 },
   12639    false,
   12640    nir_op_inot,
   12641    { &replace133_0.value },
   12642    NULL,
   12643 };
   12644 
   12645 #include "compiler/nir/nir_search_helpers.h"
   12646 static const nir_search_variable search235_0_0_0_0_0_0_0_0_0_0_0_0_0_0 = {
   12647    { nir_search_value_variable, 32 },
   12648    0, /* x */
   12649    false,
   12650    nir_type_invalid,
   12651    NULL,
   12652 };
   12653 
   12654 #include "compiler/nir/nir_search_helpers.h"
   12655 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_0_0_0_0_1 = {
   12656    { nir_search_value_constant, 0 },
   12657    nir_type_int, { 0x10 /* 16 */ },
   12658 };
   12659 #include "compiler/nir/nir_search_helpers.h"
   12660 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_0_0_0_0 = {
   12661    { nir_search_value_expression, 0 },
   12662    false,
   12663    nir_op_ishl,
   12664    { &search235_0_0_0_0_0_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_0_0_0_0_0_0_0_1.value },
   12665    NULL,
   12666 };
   12667 
   12668 #include "compiler/nir/nir_search_helpers.h"
   12669 static const nir_search_variable search235_0_0_0_0_0_0_0_0_0_0_0_0_1_0 = {
   12670    { nir_search_value_variable, 32 },
   12671    0, /* x */
   12672    false,
   12673    nir_type_invalid,
   12674    NULL,
   12675 };
   12676 
   12677 #include "compiler/nir/nir_search_helpers.h"
   12678 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_0_0_0_1_1 = {
   12679    { nir_search_value_constant, 0 },
   12680    nir_type_int, { 0x10 /* 16 */ },
   12681 };
   12682 #include "compiler/nir/nir_search_helpers.h"
   12683 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_0_0_0_1 = {
   12684    { nir_search_value_expression, 0 },
   12685    false,
   12686    nir_op_ushr,
   12687    { &search235_0_0_0_0_0_0_0_0_0_0_0_0_1_0.value, &search235_0_0_0_0_0_0_0_0_0_0_0_0_1_1.value },
   12688    NULL,
   12689 };
   12690 #include "compiler/nir/nir_search_helpers.h"
   12691 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_0_0_0 = {
   12692    { nir_search_value_expression, 0 },
   12693    false,
   12694    nir_op_ior,
   12695    { &search235_0_0_0_0_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_0_0_0_0_0_0_1.value },
   12696    NULL,
   12697 };
   12698 
   12699 #include "compiler/nir/nir_search_helpers.h"
   12700 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_0_0_1 = {
   12701    { nir_search_value_constant, 0 },
   12702    nir_type_int, { 0xff00ff /* 16711935 */ },
   12703 };
   12704 #include "compiler/nir/nir_search_helpers.h"
   12705 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_0_0 = {
   12706    { nir_search_value_expression, 0 },
   12707    false,
   12708    nir_op_iand,
   12709    { &search235_0_0_0_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_0_0_0_0_0_1.value },
   12710    NULL,
   12711 };
   12712 
   12713 #include "compiler/nir/nir_search_helpers.h"
   12714 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_0_1 = {
   12715    { nir_search_value_constant, 0 },
   12716    nir_type_int, { 0x8 /* 8 */ },
   12717 };
   12718 #include "compiler/nir/nir_search_helpers.h"
   12719 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_0 = {
   12720    { nir_search_value_expression, 0 },
   12721    false,
   12722    nir_op_ishl,
   12723    { &search235_0_0_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_0_0_0_0_1.value },
   12724    NULL,
   12725 };
   12726 
   12727 #include "compiler/nir/nir_search_helpers.h"
   12728 static const nir_search_variable search235_0_0_0_0_0_0_0_0_0_1_0_0_0_0 = {
   12729    { nir_search_value_variable, 32 },
   12730    0, /* x */
   12731    false,
   12732    nir_type_invalid,
   12733    NULL,
   12734 };
   12735 
   12736 #include "compiler/nir/nir_search_helpers.h"
   12737 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_1_0_0_0_1 = {
   12738    { nir_search_value_constant, 0 },
   12739    nir_type_int, { 0x10 /* 16 */ },
   12740 };
   12741 #include "compiler/nir/nir_search_helpers.h"
   12742 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_1_0_0_0 = {
   12743    { nir_search_value_expression, 0 },
   12744    false,
   12745    nir_op_ishl,
   12746    { &search235_0_0_0_0_0_0_0_0_0_1_0_0_0_0.value, &search235_0_0_0_0_0_0_0_0_0_1_0_0_0_1.value },
   12747    NULL,
   12748 };
   12749 
   12750 #include "compiler/nir/nir_search_helpers.h"
   12751 static const nir_search_variable search235_0_0_0_0_0_0_0_0_0_1_0_0_1_0 = {
   12752    { nir_search_value_variable, 32 },
   12753    0, /* x */
   12754    false,
   12755    nir_type_invalid,
   12756    NULL,
   12757 };
   12758 
   12759 #include "compiler/nir/nir_search_helpers.h"
   12760 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_1_0_0_1_1 = {
   12761    { nir_search_value_constant, 0 },
   12762    nir_type_int, { 0x10 /* 16 */ },
   12763 };
   12764 #include "compiler/nir/nir_search_helpers.h"
   12765 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_1_0_0_1 = {
   12766    { nir_search_value_expression, 0 },
   12767    false,
   12768    nir_op_ushr,
   12769    { &search235_0_0_0_0_0_0_0_0_0_1_0_0_1_0.value, &search235_0_0_0_0_0_0_0_0_0_1_0_0_1_1.value },
   12770    NULL,
   12771 };
   12772 #include "compiler/nir/nir_search_helpers.h"
   12773 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_1_0_0 = {
   12774    { nir_search_value_expression, 0 },
   12775    false,
   12776    nir_op_ior,
   12777    { &search235_0_0_0_0_0_0_0_0_0_1_0_0_0.value, &search235_0_0_0_0_0_0_0_0_0_1_0_0_1.value },
   12778    NULL,
   12779 };
   12780 
   12781 #include "compiler/nir/nir_search_helpers.h"
   12782 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_1_0_1 = {
   12783    { nir_search_value_constant, 0 },
   12784    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   12785 };
   12786 #include "compiler/nir/nir_search_helpers.h"
   12787 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_1_0 = {
   12788    { nir_search_value_expression, 0 },
   12789    false,
   12790    nir_op_iand,
   12791    { &search235_0_0_0_0_0_0_0_0_0_1_0_0.value, &search235_0_0_0_0_0_0_0_0_0_1_0_1.value },
   12792    NULL,
   12793 };
   12794 
   12795 #include "compiler/nir/nir_search_helpers.h"
   12796 static const nir_search_constant search235_0_0_0_0_0_0_0_0_0_1_1 = {
   12797    { nir_search_value_constant, 0 },
   12798    nir_type_int, { 0x8 /* 8 */ },
   12799 };
   12800 #include "compiler/nir/nir_search_helpers.h"
   12801 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0_1 = {
   12802    { nir_search_value_expression, 0 },
   12803    false,
   12804    nir_op_ushr,
   12805    { &search235_0_0_0_0_0_0_0_0_0_1_0.value, &search235_0_0_0_0_0_0_0_0_0_1_1.value },
   12806    NULL,
   12807 };
   12808 #include "compiler/nir/nir_search_helpers.h"
   12809 static const nir_search_expression search235_0_0_0_0_0_0_0_0_0 = {
   12810    { nir_search_value_expression, 0 },
   12811    false,
   12812    nir_op_ior,
   12813    { &search235_0_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_0_0_0_1.value },
   12814    NULL,
   12815 };
   12816 
   12817 #include "compiler/nir/nir_search_helpers.h"
   12818 static const nir_search_constant search235_0_0_0_0_0_0_0_0_1 = {
   12819    { nir_search_value_constant, 0 },
   12820    nir_type_int, { 0xf0f0f0f /* 252645135 */ },
   12821 };
   12822 #include "compiler/nir/nir_search_helpers.h"
   12823 static const nir_search_expression search235_0_0_0_0_0_0_0_0 = {
   12824    { nir_search_value_expression, 0 },
   12825    false,
   12826    nir_op_iand,
   12827    { &search235_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_0_0_1.value },
   12828    NULL,
   12829 };
   12830 
   12831 #include "compiler/nir/nir_search_helpers.h"
   12832 static const nir_search_constant search235_0_0_0_0_0_0_0_1 = {
   12833    { nir_search_value_constant, 0 },
   12834    nir_type_int, { 0x4 /* 4 */ },
   12835 };
   12836 #include "compiler/nir/nir_search_helpers.h"
   12837 static const nir_search_expression search235_0_0_0_0_0_0_0 = {
   12838    { nir_search_value_expression, 0 },
   12839    false,
   12840    nir_op_ishl,
   12841    { &search235_0_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_0_1.value },
   12842    NULL,
   12843 };
   12844 
   12845 #include "compiler/nir/nir_search_helpers.h"
   12846 static const nir_search_variable search235_0_0_0_0_0_0_1_0_0_0_0_0_0_0 = {
   12847    { nir_search_value_variable, 32 },
   12848    0, /* x */
   12849    false,
   12850    nir_type_invalid,
   12851    NULL,
   12852 };
   12853 
   12854 #include "compiler/nir/nir_search_helpers.h"
   12855 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_0_0_0_0_1 = {
   12856    { nir_search_value_constant, 0 },
   12857    nir_type_int, { 0x10 /* 16 */ },
   12858 };
   12859 #include "compiler/nir/nir_search_helpers.h"
   12860 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_0_0_0_0 = {
   12861    { nir_search_value_expression, 0 },
   12862    false,
   12863    nir_op_ishl,
   12864    { &search235_0_0_0_0_0_0_1_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_1_0_0_0_0_0_0_1.value },
   12865    NULL,
   12866 };
   12867 
   12868 #include "compiler/nir/nir_search_helpers.h"
   12869 static const nir_search_variable search235_0_0_0_0_0_0_1_0_0_0_0_0_1_0 = {
   12870    { nir_search_value_variable, 32 },
   12871    0, /* x */
   12872    false,
   12873    nir_type_invalid,
   12874    NULL,
   12875 };
   12876 
   12877 #include "compiler/nir/nir_search_helpers.h"
   12878 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_0_0_0_1_1 = {
   12879    { nir_search_value_constant, 0 },
   12880    nir_type_int, { 0x10 /* 16 */ },
   12881 };
   12882 #include "compiler/nir/nir_search_helpers.h"
   12883 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_0_0_0_1 = {
   12884    { nir_search_value_expression, 0 },
   12885    false,
   12886    nir_op_ushr,
   12887    { &search235_0_0_0_0_0_0_1_0_0_0_0_0_1_0.value, &search235_0_0_0_0_0_0_1_0_0_0_0_0_1_1.value },
   12888    NULL,
   12889 };
   12890 #include "compiler/nir/nir_search_helpers.h"
   12891 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_0_0_0 = {
   12892    { nir_search_value_expression, 0 },
   12893    false,
   12894    nir_op_ior,
   12895    { &search235_0_0_0_0_0_0_1_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_1_0_0_0_0_0_1.value },
   12896    NULL,
   12897 };
   12898 
   12899 #include "compiler/nir/nir_search_helpers.h"
   12900 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_0_0_1 = {
   12901    { nir_search_value_constant, 0 },
   12902    nir_type_int, { 0xff00ff /* 16711935 */ },
   12903 };
   12904 #include "compiler/nir/nir_search_helpers.h"
   12905 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_0_0 = {
   12906    { nir_search_value_expression, 0 },
   12907    false,
   12908    nir_op_iand,
   12909    { &search235_0_0_0_0_0_0_1_0_0_0_0_0.value, &search235_0_0_0_0_0_0_1_0_0_0_0_1.value },
   12910    NULL,
   12911 };
   12912 
   12913 #include "compiler/nir/nir_search_helpers.h"
   12914 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_0_1 = {
   12915    { nir_search_value_constant, 0 },
   12916    nir_type_int, { 0x8 /* 8 */ },
   12917 };
   12918 #include "compiler/nir/nir_search_helpers.h"
   12919 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_0 = {
   12920    { nir_search_value_expression, 0 },
   12921    false,
   12922    nir_op_ishl,
   12923    { &search235_0_0_0_0_0_0_1_0_0_0_0.value, &search235_0_0_0_0_0_0_1_0_0_0_1.value },
   12924    NULL,
   12925 };
   12926 
   12927 #include "compiler/nir/nir_search_helpers.h"
   12928 static const nir_search_variable search235_0_0_0_0_0_0_1_0_0_1_0_0_0_0 = {
   12929    { nir_search_value_variable, 32 },
   12930    0, /* x */
   12931    false,
   12932    nir_type_invalid,
   12933    NULL,
   12934 };
   12935 
   12936 #include "compiler/nir/nir_search_helpers.h"
   12937 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_1_0_0_0_1 = {
   12938    { nir_search_value_constant, 0 },
   12939    nir_type_int, { 0x10 /* 16 */ },
   12940 };
   12941 #include "compiler/nir/nir_search_helpers.h"
   12942 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_1_0_0_0 = {
   12943    { nir_search_value_expression, 0 },
   12944    false,
   12945    nir_op_ishl,
   12946    { &search235_0_0_0_0_0_0_1_0_0_1_0_0_0_0.value, &search235_0_0_0_0_0_0_1_0_0_1_0_0_0_1.value },
   12947    NULL,
   12948 };
   12949 
   12950 #include "compiler/nir/nir_search_helpers.h"
   12951 static const nir_search_variable search235_0_0_0_0_0_0_1_0_0_1_0_0_1_0 = {
   12952    { nir_search_value_variable, 32 },
   12953    0, /* x */
   12954    false,
   12955    nir_type_invalid,
   12956    NULL,
   12957 };
   12958 
   12959 #include "compiler/nir/nir_search_helpers.h"
   12960 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_1_0_0_1_1 = {
   12961    { nir_search_value_constant, 0 },
   12962    nir_type_int, { 0x10 /* 16 */ },
   12963 };
   12964 #include "compiler/nir/nir_search_helpers.h"
   12965 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_1_0_0_1 = {
   12966    { nir_search_value_expression, 0 },
   12967    false,
   12968    nir_op_ushr,
   12969    { &search235_0_0_0_0_0_0_1_0_0_1_0_0_1_0.value, &search235_0_0_0_0_0_0_1_0_0_1_0_0_1_1.value },
   12970    NULL,
   12971 };
   12972 #include "compiler/nir/nir_search_helpers.h"
   12973 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_1_0_0 = {
   12974    { nir_search_value_expression, 0 },
   12975    false,
   12976    nir_op_ior,
   12977    { &search235_0_0_0_0_0_0_1_0_0_1_0_0_0.value, &search235_0_0_0_0_0_0_1_0_0_1_0_0_1.value },
   12978    NULL,
   12979 };
   12980 
   12981 #include "compiler/nir/nir_search_helpers.h"
   12982 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_1_0_1 = {
   12983    { nir_search_value_constant, 0 },
   12984    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   12985 };
   12986 #include "compiler/nir/nir_search_helpers.h"
   12987 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_1_0 = {
   12988    { nir_search_value_expression, 0 },
   12989    false,
   12990    nir_op_iand,
   12991    { &search235_0_0_0_0_0_0_1_0_0_1_0_0.value, &search235_0_0_0_0_0_0_1_0_0_1_0_1.value },
   12992    NULL,
   12993 };
   12994 
   12995 #include "compiler/nir/nir_search_helpers.h"
   12996 static const nir_search_constant search235_0_0_0_0_0_0_1_0_0_1_1 = {
   12997    { nir_search_value_constant, 0 },
   12998    nir_type_int, { 0x8 /* 8 */ },
   12999 };
   13000 #include "compiler/nir/nir_search_helpers.h"
   13001 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0_1 = {
   13002    { nir_search_value_expression, 0 },
   13003    false,
   13004    nir_op_ushr,
   13005    { &search235_0_0_0_0_0_0_1_0_0_1_0.value, &search235_0_0_0_0_0_0_1_0_0_1_1.value },
   13006    NULL,
   13007 };
   13008 #include "compiler/nir/nir_search_helpers.h"
   13009 static const nir_search_expression search235_0_0_0_0_0_0_1_0_0 = {
   13010    { nir_search_value_expression, 0 },
   13011    false,
   13012    nir_op_ior,
   13013    { &search235_0_0_0_0_0_0_1_0_0_0.value, &search235_0_0_0_0_0_0_1_0_0_1.value },
   13014    NULL,
   13015 };
   13016 
   13017 #include "compiler/nir/nir_search_helpers.h"
   13018 static const nir_search_constant search235_0_0_0_0_0_0_1_0_1 = {
   13019    { nir_search_value_constant, 0 },
   13020    nir_type_int, { 0xf0f0f0f0 /* 4042322160 */ },
   13021 };
   13022 #include "compiler/nir/nir_search_helpers.h"
   13023 static const nir_search_expression search235_0_0_0_0_0_0_1_0 = {
   13024    { nir_search_value_expression, 0 },
   13025    false,
   13026    nir_op_iand,
   13027    { &search235_0_0_0_0_0_0_1_0_0.value, &search235_0_0_0_0_0_0_1_0_1.value },
   13028    NULL,
   13029 };
   13030 
   13031 #include "compiler/nir/nir_search_helpers.h"
   13032 static const nir_search_constant search235_0_0_0_0_0_0_1_1 = {
   13033    { nir_search_value_constant, 0 },
   13034    nir_type_int, { 0x4 /* 4 */ },
   13035 };
   13036 #include "compiler/nir/nir_search_helpers.h"
   13037 static const nir_search_expression search235_0_0_0_0_0_0_1 = {
   13038    { nir_search_value_expression, 0 },
   13039    false,
   13040    nir_op_ushr,
   13041    { &search235_0_0_0_0_0_0_1_0.value, &search235_0_0_0_0_0_0_1_1.value },
   13042    NULL,
   13043 };
   13044 #include "compiler/nir/nir_search_helpers.h"
   13045 static const nir_search_expression search235_0_0_0_0_0_0 = {
   13046    { nir_search_value_expression, 0 },
   13047    false,
   13048    nir_op_ior,
   13049    { &search235_0_0_0_0_0_0_0.value, &search235_0_0_0_0_0_0_1.value },
   13050    NULL,
   13051 };
   13052 
   13053 #include "compiler/nir/nir_search_helpers.h"
   13054 static const nir_search_constant search235_0_0_0_0_0_1 = {
   13055    { nir_search_value_constant, 0 },
   13056    nir_type_int, { 0x33333333 /* 858993459 */ },
   13057 };
   13058 #include "compiler/nir/nir_search_helpers.h"
   13059 static const nir_search_expression search235_0_0_0_0_0 = {
   13060    { nir_search_value_expression, 0 },
   13061    false,
   13062    nir_op_iand,
   13063    { &search235_0_0_0_0_0_0.value, &search235_0_0_0_0_0_1.value },
   13064    NULL,
   13065 };
   13066 
   13067 #include "compiler/nir/nir_search_helpers.h"
   13068 static const nir_search_constant search235_0_0_0_0_1 = {
   13069    { nir_search_value_constant, 0 },
   13070    nir_type_int, { 0x2 /* 2 */ },
   13071 };
   13072 #include "compiler/nir/nir_search_helpers.h"
   13073 static const nir_search_expression search235_0_0_0_0 = {
   13074    { nir_search_value_expression, 0 },
   13075    false,
   13076    nir_op_ishl,
   13077    { &search235_0_0_0_0_0.value, &search235_0_0_0_0_1.value },
   13078    NULL,
   13079 };
   13080 
   13081 #include "compiler/nir/nir_search_helpers.h"
   13082 static const nir_search_variable search235_0_0_0_1_0_0_0_0_0_0_0_0_0_0 = {
   13083    { nir_search_value_variable, 32 },
   13084    0, /* x */
   13085    false,
   13086    nir_type_invalid,
   13087    NULL,
   13088 };
   13089 
   13090 #include "compiler/nir/nir_search_helpers.h"
   13091 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_0_0_0_0_1 = {
   13092    { nir_search_value_constant, 0 },
   13093    nir_type_int, { 0x10 /* 16 */ },
   13094 };
   13095 #include "compiler/nir/nir_search_helpers.h"
   13096 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_0_0_0_0 = {
   13097    { nir_search_value_expression, 0 },
   13098    false,
   13099    nir_op_ishl,
   13100    { &search235_0_0_0_1_0_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_1_0_0_0_0_0_0_0_0_0_1.value },
   13101    NULL,
   13102 };
   13103 
   13104 #include "compiler/nir/nir_search_helpers.h"
   13105 static const nir_search_variable search235_0_0_0_1_0_0_0_0_0_0_0_0_1_0 = {
   13106    { nir_search_value_variable, 32 },
   13107    0, /* x */
   13108    false,
   13109    nir_type_invalid,
   13110    NULL,
   13111 };
   13112 
   13113 #include "compiler/nir/nir_search_helpers.h"
   13114 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_0_0_0_1_1 = {
   13115    { nir_search_value_constant, 0 },
   13116    nir_type_int, { 0x10 /* 16 */ },
   13117 };
   13118 #include "compiler/nir/nir_search_helpers.h"
   13119 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_0_0_0_1 = {
   13120    { nir_search_value_expression, 0 },
   13121    false,
   13122    nir_op_ushr,
   13123    { &search235_0_0_0_1_0_0_0_0_0_0_0_0_1_0.value, &search235_0_0_0_1_0_0_0_0_0_0_0_0_1_1.value },
   13124    NULL,
   13125 };
   13126 #include "compiler/nir/nir_search_helpers.h"
   13127 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_0_0_0 = {
   13128    { nir_search_value_expression, 0 },
   13129    false,
   13130    nir_op_ior,
   13131    { &search235_0_0_0_1_0_0_0_0_0_0_0_0_0.value, &search235_0_0_0_1_0_0_0_0_0_0_0_0_1.value },
   13132    NULL,
   13133 };
   13134 
   13135 #include "compiler/nir/nir_search_helpers.h"
   13136 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_0_0_1 = {
   13137    { nir_search_value_constant, 0 },
   13138    nir_type_int, { 0xff00ff /* 16711935 */ },
   13139 };
   13140 #include "compiler/nir/nir_search_helpers.h"
   13141 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_0_0 = {
   13142    { nir_search_value_expression, 0 },
   13143    false,
   13144    nir_op_iand,
   13145    { &search235_0_0_0_1_0_0_0_0_0_0_0_0.value, &search235_0_0_0_1_0_0_0_0_0_0_0_1.value },
   13146    NULL,
   13147 };
   13148 
   13149 #include "compiler/nir/nir_search_helpers.h"
   13150 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_0_1 = {
   13151    { nir_search_value_constant, 0 },
   13152    nir_type_int, { 0x8 /* 8 */ },
   13153 };
   13154 #include "compiler/nir/nir_search_helpers.h"
   13155 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_0 = {
   13156    { nir_search_value_expression, 0 },
   13157    false,
   13158    nir_op_ishl,
   13159    { &search235_0_0_0_1_0_0_0_0_0_0_0.value, &search235_0_0_0_1_0_0_0_0_0_0_1.value },
   13160    NULL,
   13161 };
   13162 
   13163 #include "compiler/nir/nir_search_helpers.h"
   13164 static const nir_search_variable search235_0_0_0_1_0_0_0_0_0_1_0_0_0_0 = {
   13165    { nir_search_value_variable, 32 },
   13166    0, /* x */
   13167    false,
   13168    nir_type_invalid,
   13169    NULL,
   13170 };
   13171 
   13172 #include "compiler/nir/nir_search_helpers.h"
   13173 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_1_0_0_0_1 = {
   13174    { nir_search_value_constant, 0 },
   13175    nir_type_int, { 0x10 /* 16 */ },
   13176 };
   13177 #include "compiler/nir/nir_search_helpers.h"
   13178 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_1_0_0_0 = {
   13179    { nir_search_value_expression, 0 },
   13180    false,
   13181    nir_op_ishl,
   13182    { &search235_0_0_0_1_0_0_0_0_0_1_0_0_0_0.value, &search235_0_0_0_1_0_0_0_0_0_1_0_0_0_1.value },
   13183    NULL,
   13184 };
   13185 
   13186 #include "compiler/nir/nir_search_helpers.h"
   13187 static const nir_search_variable search235_0_0_0_1_0_0_0_0_0_1_0_0_1_0 = {
   13188    { nir_search_value_variable, 32 },
   13189    0, /* x */
   13190    false,
   13191    nir_type_invalid,
   13192    NULL,
   13193 };
   13194 
   13195 #include "compiler/nir/nir_search_helpers.h"
   13196 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_1_0_0_1_1 = {
   13197    { nir_search_value_constant, 0 },
   13198    nir_type_int, { 0x10 /* 16 */ },
   13199 };
   13200 #include "compiler/nir/nir_search_helpers.h"
   13201 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_1_0_0_1 = {
   13202    { nir_search_value_expression, 0 },
   13203    false,
   13204    nir_op_ushr,
   13205    { &search235_0_0_0_1_0_0_0_0_0_1_0_0_1_0.value, &search235_0_0_0_1_0_0_0_0_0_1_0_0_1_1.value },
   13206    NULL,
   13207 };
   13208 #include "compiler/nir/nir_search_helpers.h"
   13209 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_1_0_0 = {
   13210    { nir_search_value_expression, 0 },
   13211    false,
   13212    nir_op_ior,
   13213    { &search235_0_0_0_1_0_0_0_0_0_1_0_0_0.value, &search235_0_0_0_1_0_0_0_0_0_1_0_0_1.value },
   13214    NULL,
   13215 };
   13216 
   13217 #include "compiler/nir/nir_search_helpers.h"
   13218 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_1_0_1 = {
   13219    { nir_search_value_constant, 0 },
   13220    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   13221 };
   13222 #include "compiler/nir/nir_search_helpers.h"
   13223 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_1_0 = {
   13224    { nir_search_value_expression, 0 },
   13225    false,
   13226    nir_op_iand,
   13227    { &search235_0_0_0_1_0_0_0_0_0_1_0_0.value, &search235_0_0_0_1_0_0_0_0_0_1_0_1.value },
   13228    NULL,
   13229 };
   13230 
   13231 #include "compiler/nir/nir_search_helpers.h"
   13232 static const nir_search_constant search235_0_0_0_1_0_0_0_0_0_1_1 = {
   13233    { nir_search_value_constant, 0 },
   13234    nir_type_int, { 0x8 /* 8 */ },
   13235 };
   13236 #include "compiler/nir/nir_search_helpers.h"
   13237 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0_1 = {
   13238    { nir_search_value_expression, 0 },
   13239    false,
   13240    nir_op_ushr,
   13241    { &search235_0_0_0_1_0_0_0_0_0_1_0.value, &search235_0_0_0_1_0_0_0_0_0_1_1.value },
   13242    NULL,
   13243 };
   13244 #include "compiler/nir/nir_search_helpers.h"
   13245 static const nir_search_expression search235_0_0_0_1_0_0_0_0_0 = {
   13246    { nir_search_value_expression, 0 },
   13247    false,
   13248    nir_op_ior,
   13249    { &search235_0_0_0_1_0_0_0_0_0_0.value, &search235_0_0_0_1_0_0_0_0_0_1.value },
   13250    NULL,
   13251 };
   13252 
   13253 #include "compiler/nir/nir_search_helpers.h"
   13254 static const nir_search_constant search235_0_0_0_1_0_0_0_0_1 = {
   13255    { nir_search_value_constant, 0 },
   13256    nir_type_int, { 0xf0f0f0f /* 252645135 */ },
   13257 };
   13258 #include "compiler/nir/nir_search_helpers.h"
   13259 static const nir_search_expression search235_0_0_0_1_0_0_0_0 = {
   13260    { nir_search_value_expression, 0 },
   13261    false,
   13262    nir_op_iand,
   13263    { &search235_0_0_0_1_0_0_0_0_0.value, &search235_0_0_0_1_0_0_0_0_1.value },
   13264    NULL,
   13265 };
   13266 
   13267 #include "compiler/nir/nir_search_helpers.h"
   13268 static const nir_search_constant search235_0_0_0_1_0_0_0_1 = {
   13269    { nir_search_value_constant, 0 },
   13270    nir_type_int, { 0x4 /* 4 */ },
   13271 };
   13272 #include "compiler/nir/nir_search_helpers.h"
   13273 static const nir_search_expression search235_0_0_0_1_0_0_0 = {
   13274    { nir_search_value_expression, 0 },
   13275    false,
   13276    nir_op_ishl,
   13277    { &search235_0_0_0_1_0_0_0_0.value, &search235_0_0_0_1_0_0_0_1.value },
   13278    NULL,
   13279 };
   13280 
   13281 #include "compiler/nir/nir_search_helpers.h"
   13282 static const nir_search_variable search235_0_0_0_1_0_0_1_0_0_0_0_0_0_0 = {
   13283    { nir_search_value_variable, 32 },
   13284    0, /* x */
   13285    false,
   13286    nir_type_invalid,
   13287    NULL,
   13288 };
   13289 
   13290 #include "compiler/nir/nir_search_helpers.h"
   13291 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_0_0_0_0_1 = {
   13292    { nir_search_value_constant, 0 },
   13293    nir_type_int, { 0x10 /* 16 */ },
   13294 };
   13295 #include "compiler/nir/nir_search_helpers.h"
   13296 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_0_0_0_0 = {
   13297    { nir_search_value_expression, 0 },
   13298    false,
   13299    nir_op_ishl,
   13300    { &search235_0_0_0_1_0_0_1_0_0_0_0_0_0_0.value, &search235_0_0_0_1_0_0_1_0_0_0_0_0_0_1.value },
   13301    NULL,
   13302 };
   13303 
   13304 #include "compiler/nir/nir_search_helpers.h"
   13305 static const nir_search_variable search235_0_0_0_1_0_0_1_0_0_0_0_0_1_0 = {
   13306    { nir_search_value_variable, 32 },
   13307    0, /* x */
   13308    false,
   13309    nir_type_invalid,
   13310    NULL,
   13311 };
   13312 
   13313 #include "compiler/nir/nir_search_helpers.h"
   13314 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_0_0_0_1_1 = {
   13315    { nir_search_value_constant, 0 },
   13316    nir_type_int, { 0x10 /* 16 */ },
   13317 };
   13318 #include "compiler/nir/nir_search_helpers.h"
   13319 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_0_0_0_1 = {
   13320    { nir_search_value_expression, 0 },
   13321    false,
   13322    nir_op_ushr,
   13323    { &search235_0_0_0_1_0_0_1_0_0_0_0_0_1_0.value, &search235_0_0_0_1_0_0_1_0_0_0_0_0_1_1.value },
   13324    NULL,
   13325 };
   13326 #include "compiler/nir/nir_search_helpers.h"
   13327 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_0_0_0 = {
   13328    { nir_search_value_expression, 0 },
   13329    false,
   13330    nir_op_ior,
   13331    { &search235_0_0_0_1_0_0_1_0_0_0_0_0_0.value, &search235_0_0_0_1_0_0_1_0_0_0_0_0_1.value },
   13332    NULL,
   13333 };
   13334 
   13335 #include "compiler/nir/nir_search_helpers.h"
   13336 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_0_0_1 = {
   13337    { nir_search_value_constant, 0 },
   13338    nir_type_int, { 0xff00ff /* 16711935 */ },
   13339 };
   13340 #include "compiler/nir/nir_search_helpers.h"
   13341 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_0_0 = {
   13342    { nir_search_value_expression, 0 },
   13343    false,
   13344    nir_op_iand,
   13345    { &search235_0_0_0_1_0_0_1_0_0_0_0_0.value, &search235_0_0_0_1_0_0_1_0_0_0_0_1.value },
   13346    NULL,
   13347 };
   13348 
   13349 #include "compiler/nir/nir_search_helpers.h"
   13350 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_0_1 = {
   13351    { nir_search_value_constant, 0 },
   13352    nir_type_int, { 0x8 /* 8 */ },
   13353 };
   13354 #include "compiler/nir/nir_search_helpers.h"
   13355 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_0 = {
   13356    { nir_search_value_expression, 0 },
   13357    false,
   13358    nir_op_ishl,
   13359    { &search235_0_0_0_1_0_0_1_0_0_0_0.value, &search235_0_0_0_1_0_0_1_0_0_0_1.value },
   13360    NULL,
   13361 };
   13362 
   13363 #include "compiler/nir/nir_search_helpers.h"
   13364 static const nir_search_variable search235_0_0_0_1_0_0_1_0_0_1_0_0_0_0 = {
   13365    { nir_search_value_variable, 32 },
   13366    0, /* x */
   13367    false,
   13368    nir_type_invalid,
   13369    NULL,
   13370 };
   13371 
   13372 #include "compiler/nir/nir_search_helpers.h"
   13373 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_1_0_0_0_1 = {
   13374    { nir_search_value_constant, 0 },
   13375    nir_type_int, { 0x10 /* 16 */ },
   13376 };
   13377 #include "compiler/nir/nir_search_helpers.h"
   13378 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_1_0_0_0 = {
   13379    { nir_search_value_expression, 0 },
   13380    false,
   13381    nir_op_ishl,
   13382    { &search235_0_0_0_1_0_0_1_0_0_1_0_0_0_0.value, &search235_0_0_0_1_0_0_1_0_0_1_0_0_0_1.value },
   13383    NULL,
   13384 };
   13385 
   13386 #include "compiler/nir/nir_search_helpers.h"
   13387 static const nir_search_variable search235_0_0_0_1_0_0_1_0_0_1_0_0_1_0 = {
   13388    { nir_search_value_variable, 32 },
   13389    0, /* x */
   13390    false,
   13391    nir_type_invalid,
   13392    NULL,
   13393 };
   13394 
   13395 #include "compiler/nir/nir_search_helpers.h"
   13396 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_1_0_0_1_1 = {
   13397    { nir_search_value_constant, 0 },
   13398    nir_type_int, { 0x10 /* 16 */ },
   13399 };
   13400 #include "compiler/nir/nir_search_helpers.h"
   13401 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_1_0_0_1 = {
   13402    { nir_search_value_expression, 0 },
   13403    false,
   13404    nir_op_ushr,
   13405    { &search235_0_0_0_1_0_0_1_0_0_1_0_0_1_0.value, &search235_0_0_0_1_0_0_1_0_0_1_0_0_1_1.value },
   13406    NULL,
   13407 };
   13408 #include "compiler/nir/nir_search_helpers.h"
   13409 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_1_0_0 = {
   13410    { nir_search_value_expression, 0 },
   13411    false,
   13412    nir_op_ior,
   13413    { &search235_0_0_0_1_0_0_1_0_0_1_0_0_0.value, &search235_0_0_0_1_0_0_1_0_0_1_0_0_1.value },
   13414    NULL,
   13415 };
   13416 
   13417 #include "compiler/nir/nir_search_helpers.h"
   13418 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_1_0_1 = {
   13419    { nir_search_value_constant, 0 },
   13420    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   13421 };
   13422 #include "compiler/nir/nir_search_helpers.h"
   13423 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_1_0 = {
   13424    { nir_search_value_expression, 0 },
   13425    false,
   13426    nir_op_iand,
   13427    { &search235_0_0_0_1_0_0_1_0_0_1_0_0.value, &search235_0_0_0_1_0_0_1_0_0_1_0_1.value },
   13428    NULL,
   13429 };
   13430 
   13431 #include "compiler/nir/nir_search_helpers.h"
   13432 static const nir_search_constant search235_0_0_0_1_0_0_1_0_0_1_1 = {
   13433    { nir_search_value_constant, 0 },
   13434    nir_type_int, { 0x8 /* 8 */ },
   13435 };
   13436 #include "compiler/nir/nir_search_helpers.h"
   13437 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0_1 = {
   13438    { nir_search_value_expression, 0 },
   13439    false,
   13440    nir_op_ushr,
   13441    { &search235_0_0_0_1_0_0_1_0_0_1_0.value, &search235_0_0_0_1_0_0_1_0_0_1_1.value },
   13442    NULL,
   13443 };
   13444 #include "compiler/nir/nir_search_helpers.h"
   13445 static const nir_search_expression search235_0_0_0_1_0_0_1_0_0 = {
   13446    { nir_search_value_expression, 0 },
   13447    false,
   13448    nir_op_ior,
   13449    { &search235_0_0_0_1_0_0_1_0_0_0.value, &search235_0_0_0_1_0_0_1_0_0_1.value },
   13450    NULL,
   13451 };
   13452 
   13453 #include "compiler/nir/nir_search_helpers.h"
   13454 static const nir_search_constant search235_0_0_0_1_0_0_1_0_1 = {
   13455    { nir_search_value_constant, 0 },
   13456    nir_type_int, { 0xf0f0f0f0 /* 4042322160 */ },
   13457 };
   13458 #include "compiler/nir/nir_search_helpers.h"
   13459 static const nir_search_expression search235_0_0_0_1_0_0_1_0 = {
   13460    { nir_search_value_expression, 0 },
   13461    false,
   13462    nir_op_iand,
   13463    { &search235_0_0_0_1_0_0_1_0_0.value, &search235_0_0_0_1_0_0_1_0_1.value },
   13464    NULL,
   13465 };
   13466 
   13467 #include "compiler/nir/nir_search_helpers.h"
   13468 static const nir_search_constant search235_0_0_0_1_0_0_1_1 = {
   13469    { nir_search_value_constant, 0 },
   13470    nir_type_int, { 0x4 /* 4 */ },
   13471 };
   13472 #include "compiler/nir/nir_search_helpers.h"
   13473 static const nir_search_expression search235_0_0_0_1_0_0_1 = {
   13474    { nir_search_value_expression, 0 },
   13475    false,
   13476    nir_op_ushr,
   13477    { &search235_0_0_0_1_0_0_1_0.value, &search235_0_0_0_1_0_0_1_1.value },
   13478    NULL,
   13479 };
   13480 #include "compiler/nir/nir_search_helpers.h"
   13481 static const nir_search_expression search235_0_0_0_1_0_0 = {
   13482    { nir_search_value_expression, 0 },
   13483    false,
   13484    nir_op_ior,
   13485    { &search235_0_0_0_1_0_0_0.value, &search235_0_0_0_1_0_0_1.value },
   13486    NULL,
   13487 };
   13488 
   13489 #include "compiler/nir/nir_search_helpers.h"
   13490 static const nir_search_constant search235_0_0_0_1_0_1 = {
   13491    { nir_search_value_constant, 0 },
   13492    nir_type_int, { 0xcccccccc /* 3435973836 */ },
   13493 };
   13494 #include "compiler/nir/nir_search_helpers.h"
   13495 static const nir_search_expression search235_0_0_0_1_0 = {
   13496    { nir_search_value_expression, 0 },
   13497    false,
   13498    nir_op_iand,
   13499    { &search235_0_0_0_1_0_0.value, &search235_0_0_0_1_0_1.value },
   13500    NULL,
   13501 };
   13502 
   13503 #include "compiler/nir/nir_search_helpers.h"
   13504 static const nir_search_constant search235_0_0_0_1_1 = {
   13505    { nir_search_value_constant, 0 },
   13506    nir_type_int, { 0x2 /* 2 */ },
   13507 };
   13508 #include "compiler/nir/nir_search_helpers.h"
   13509 static const nir_search_expression search235_0_0_0_1 = {
   13510    { nir_search_value_expression, 0 },
   13511    false,
   13512    nir_op_ushr,
   13513    { &search235_0_0_0_1_0.value, &search235_0_0_0_1_1.value },
   13514    NULL,
   13515 };
   13516 #include "compiler/nir/nir_search_helpers.h"
   13517 static const nir_search_expression search235_0_0_0 = {
   13518    { nir_search_value_expression, 0 },
   13519    false,
   13520    nir_op_ior,
   13521    { &search235_0_0_0_0.value, &search235_0_0_0_1.value },
   13522    NULL,
   13523 };
   13524 
   13525 #include "compiler/nir/nir_search_helpers.h"
   13526 static const nir_search_constant search235_0_0_1 = {
   13527    { nir_search_value_constant, 0 },
   13528    nir_type_int, { 0x55555555 /* 1431655765 */ },
   13529 };
   13530 #include "compiler/nir/nir_search_helpers.h"
   13531 static const nir_search_expression search235_0_0 = {
   13532    { nir_search_value_expression, 0 },
   13533    false,
   13534    nir_op_iand,
   13535    { &search235_0_0_0.value, &search235_0_0_1.value },
   13536    NULL,
   13537 };
   13538 
   13539 #include "compiler/nir/nir_search_helpers.h"
   13540 static const nir_search_constant search235_0_1 = {
   13541    { nir_search_value_constant, 0 },
   13542    nir_type_int, { 0x1 /* 1 */ },
   13543 };
   13544 #include "compiler/nir/nir_search_helpers.h"
   13545 static const nir_search_expression search235_0 = {
   13546    { nir_search_value_expression, 0 },
   13547    false,
   13548    nir_op_ishl,
   13549    { &search235_0_0.value, &search235_0_1.value },
   13550    NULL,
   13551 };
   13552 
   13553 #include "compiler/nir/nir_search_helpers.h"
   13554 static const nir_search_variable search235_1_0_0_0_0_0_0_0_0_0_0_0_0_0 = {
   13555    { nir_search_value_variable, 32 },
   13556    0, /* x */
   13557    false,
   13558    nir_type_invalid,
   13559    NULL,
   13560 };
   13561 
   13562 #include "compiler/nir/nir_search_helpers.h"
   13563 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_0_0_0_0_1 = {
   13564    { nir_search_value_constant, 0 },
   13565    nir_type_int, { 0x10 /* 16 */ },
   13566 };
   13567 #include "compiler/nir/nir_search_helpers.h"
   13568 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_0_0_0_0 = {
   13569    { nir_search_value_expression, 0 },
   13570    false,
   13571    nir_op_ishl,
   13572    { &search235_1_0_0_0_0_0_0_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_0_0_0_0_0_0_0_1.value },
   13573    NULL,
   13574 };
   13575 
   13576 #include "compiler/nir/nir_search_helpers.h"
   13577 static const nir_search_variable search235_1_0_0_0_0_0_0_0_0_0_0_0_1_0 = {
   13578    { nir_search_value_variable, 32 },
   13579    0, /* x */
   13580    false,
   13581    nir_type_invalid,
   13582    NULL,
   13583 };
   13584 
   13585 #include "compiler/nir/nir_search_helpers.h"
   13586 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_0_0_0_1_1 = {
   13587    { nir_search_value_constant, 0 },
   13588    nir_type_int, { 0x10 /* 16 */ },
   13589 };
   13590 #include "compiler/nir/nir_search_helpers.h"
   13591 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_0_0_0_1 = {
   13592    { nir_search_value_expression, 0 },
   13593    false,
   13594    nir_op_ushr,
   13595    { &search235_1_0_0_0_0_0_0_0_0_0_0_0_1_0.value, &search235_1_0_0_0_0_0_0_0_0_0_0_0_1_1.value },
   13596    NULL,
   13597 };
   13598 #include "compiler/nir/nir_search_helpers.h"
   13599 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_0_0_0 = {
   13600    { nir_search_value_expression, 0 },
   13601    false,
   13602    nir_op_ior,
   13603    { &search235_1_0_0_0_0_0_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_0_0_0_0_0_0_1.value },
   13604    NULL,
   13605 };
   13606 
   13607 #include "compiler/nir/nir_search_helpers.h"
   13608 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_0_0_1 = {
   13609    { nir_search_value_constant, 0 },
   13610    nir_type_int, { 0xff00ff /* 16711935 */ },
   13611 };
   13612 #include "compiler/nir/nir_search_helpers.h"
   13613 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_0_0 = {
   13614    { nir_search_value_expression, 0 },
   13615    false,
   13616    nir_op_iand,
   13617    { &search235_1_0_0_0_0_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_0_0_0_0_0_1.value },
   13618    NULL,
   13619 };
   13620 
   13621 #include "compiler/nir/nir_search_helpers.h"
   13622 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_0_1 = {
   13623    { nir_search_value_constant, 0 },
   13624    nir_type_int, { 0x8 /* 8 */ },
   13625 };
   13626 #include "compiler/nir/nir_search_helpers.h"
   13627 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_0 = {
   13628    { nir_search_value_expression, 0 },
   13629    false,
   13630    nir_op_ishl,
   13631    { &search235_1_0_0_0_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_0_0_0_0_1.value },
   13632    NULL,
   13633 };
   13634 
   13635 #include "compiler/nir/nir_search_helpers.h"
   13636 static const nir_search_variable search235_1_0_0_0_0_0_0_0_0_1_0_0_0_0 = {
   13637    { nir_search_value_variable, 32 },
   13638    0, /* x */
   13639    false,
   13640    nir_type_invalid,
   13641    NULL,
   13642 };
   13643 
   13644 #include "compiler/nir/nir_search_helpers.h"
   13645 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_1_0_0_0_1 = {
   13646    { nir_search_value_constant, 0 },
   13647    nir_type_int, { 0x10 /* 16 */ },
   13648 };
   13649 #include "compiler/nir/nir_search_helpers.h"
   13650 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_1_0_0_0 = {
   13651    { nir_search_value_expression, 0 },
   13652    false,
   13653    nir_op_ishl,
   13654    { &search235_1_0_0_0_0_0_0_0_0_1_0_0_0_0.value, &search235_1_0_0_0_0_0_0_0_0_1_0_0_0_1.value },
   13655    NULL,
   13656 };
   13657 
   13658 #include "compiler/nir/nir_search_helpers.h"
   13659 static const nir_search_variable search235_1_0_0_0_0_0_0_0_0_1_0_0_1_0 = {
   13660    { nir_search_value_variable, 32 },
   13661    0, /* x */
   13662    false,
   13663    nir_type_invalid,
   13664    NULL,
   13665 };
   13666 
   13667 #include "compiler/nir/nir_search_helpers.h"
   13668 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_1_0_0_1_1 = {
   13669    { nir_search_value_constant, 0 },
   13670    nir_type_int, { 0x10 /* 16 */ },
   13671 };
   13672 #include "compiler/nir/nir_search_helpers.h"
   13673 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_1_0_0_1 = {
   13674    { nir_search_value_expression, 0 },
   13675    false,
   13676    nir_op_ushr,
   13677    { &search235_1_0_0_0_0_0_0_0_0_1_0_0_1_0.value, &search235_1_0_0_0_0_0_0_0_0_1_0_0_1_1.value },
   13678    NULL,
   13679 };
   13680 #include "compiler/nir/nir_search_helpers.h"
   13681 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_1_0_0 = {
   13682    { nir_search_value_expression, 0 },
   13683    false,
   13684    nir_op_ior,
   13685    { &search235_1_0_0_0_0_0_0_0_0_1_0_0_0.value, &search235_1_0_0_0_0_0_0_0_0_1_0_0_1.value },
   13686    NULL,
   13687 };
   13688 
   13689 #include "compiler/nir/nir_search_helpers.h"
   13690 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_1_0_1 = {
   13691    { nir_search_value_constant, 0 },
   13692    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   13693 };
   13694 #include "compiler/nir/nir_search_helpers.h"
   13695 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_1_0 = {
   13696    { nir_search_value_expression, 0 },
   13697    false,
   13698    nir_op_iand,
   13699    { &search235_1_0_0_0_0_0_0_0_0_1_0_0.value, &search235_1_0_0_0_0_0_0_0_0_1_0_1.value },
   13700    NULL,
   13701 };
   13702 
   13703 #include "compiler/nir/nir_search_helpers.h"
   13704 static const nir_search_constant search235_1_0_0_0_0_0_0_0_0_1_1 = {
   13705    { nir_search_value_constant, 0 },
   13706    nir_type_int, { 0x8 /* 8 */ },
   13707 };
   13708 #include "compiler/nir/nir_search_helpers.h"
   13709 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0_1 = {
   13710    { nir_search_value_expression, 0 },
   13711    false,
   13712    nir_op_ushr,
   13713    { &search235_1_0_0_0_0_0_0_0_0_1_0.value, &search235_1_0_0_0_0_0_0_0_0_1_1.value },
   13714    NULL,
   13715 };
   13716 #include "compiler/nir/nir_search_helpers.h"
   13717 static const nir_search_expression search235_1_0_0_0_0_0_0_0_0 = {
   13718    { nir_search_value_expression, 0 },
   13719    false,
   13720    nir_op_ior,
   13721    { &search235_1_0_0_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_0_0_0_1.value },
   13722    NULL,
   13723 };
   13724 
   13725 #include "compiler/nir/nir_search_helpers.h"
   13726 static const nir_search_constant search235_1_0_0_0_0_0_0_0_1 = {
   13727    { nir_search_value_constant, 0 },
   13728    nir_type_int, { 0xf0f0f0f /* 252645135 */ },
   13729 };
   13730 #include "compiler/nir/nir_search_helpers.h"
   13731 static const nir_search_expression search235_1_0_0_0_0_0_0_0 = {
   13732    { nir_search_value_expression, 0 },
   13733    false,
   13734    nir_op_iand,
   13735    { &search235_1_0_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_0_0_1.value },
   13736    NULL,
   13737 };
   13738 
   13739 #include "compiler/nir/nir_search_helpers.h"
   13740 static const nir_search_constant search235_1_0_0_0_0_0_0_1 = {
   13741    { nir_search_value_constant, 0 },
   13742    nir_type_int, { 0x4 /* 4 */ },
   13743 };
   13744 #include "compiler/nir/nir_search_helpers.h"
   13745 static const nir_search_expression search235_1_0_0_0_0_0_0 = {
   13746    { nir_search_value_expression, 0 },
   13747    false,
   13748    nir_op_ishl,
   13749    { &search235_1_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_0_1.value },
   13750    NULL,
   13751 };
   13752 
   13753 #include "compiler/nir/nir_search_helpers.h"
   13754 static const nir_search_variable search235_1_0_0_0_0_0_1_0_0_0_0_0_0_0 = {
   13755    { nir_search_value_variable, 32 },
   13756    0, /* x */
   13757    false,
   13758    nir_type_invalid,
   13759    NULL,
   13760 };
   13761 
   13762 #include "compiler/nir/nir_search_helpers.h"
   13763 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_0_0_0_0_1 = {
   13764    { nir_search_value_constant, 0 },
   13765    nir_type_int, { 0x10 /* 16 */ },
   13766 };
   13767 #include "compiler/nir/nir_search_helpers.h"
   13768 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_0_0_0_0 = {
   13769    { nir_search_value_expression, 0 },
   13770    false,
   13771    nir_op_ishl,
   13772    { &search235_1_0_0_0_0_0_1_0_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_1_0_0_0_0_0_0_1.value },
   13773    NULL,
   13774 };
   13775 
   13776 #include "compiler/nir/nir_search_helpers.h"
   13777 static const nir_search_variable search235_1_0_0_0_0_0_1_0_0_0_0_0_1_0 = {
   13778    { nir_search_value_variable, 32 },
   13779    0, /* x */
   13780    false,
   13781    nir_type_invalid,
   13782    NULL,
   13783 };
   13784 
   13785 #include "compiler/nir/nir_search_helpers.h"
   13786 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_0_0_0_1_1 = {
   13787    { nir_search_value_constant, 0 },
   13788    nir_type_int, { 0x10 /* 16 */ },
   13789 };
   13790 #include "compiler/nir/nir_search_helpers.h"
   13791 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_0_0_0_1 = {
   13792    { nir_search_value_expression, 0 },
   13793    false,
   13794    nir_op_ushr,
   13795    { &search235_1_0_0_0_0_0_1_0_0_0_0_0_1_0.value, &search235_1_0_0_0_0_0_1_0_0_0_0_0_1_1.value },
   13796    NULL,
   13797 };
   13798 #include "compiler/nir/nir_search_helpers.h"
   13799 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_0_0_0 = {
   13800    { nir_search_value_expression, 0 },
   13801    false,
   13802    nir_op_ior,
   13803    { &search235_1_0_0_0_0_0_1_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_1_0_0_0_0_0_1.value },
   13804    NULL,
   13805 };
   13806 
   13807 #include "compiler/nir/nir_search_helpers.h"
   13808 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_0_0_1 = {
   13809    { nir_search_value_constant, 0 },
   13810    nir_type_int, { 0xff00ff /* 16711935 */ },
   13811 };
   13812 #include "compiler/nir/nir_search_helpers.h"
   13813 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_0_0 = {
   13814    { nir_search_value_expression, 0 },
   13815    false,
   13816    nir_op_iand,
   13817    { &search235_1_0_0_0_0_0_1_0_0_0_0_0.value, &search235_1_0_0_0_0_0_1_0_0_0_0_1.value },
   13818    NULL,
   13819 };
   13820 
   13821 #include "compiler/nir/nir_search_helpers.h"
   13822 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_0_1 = {
   13823    { nir_search_value_constant, 0 },
   13824    nir_type_int, { 0x8 /* 8 */ },
   13825 };
   13826 #include "compiler/nir/nir_search_helpers.h"
   13827 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_0 = {
   13828    { nir_search_value_expression, 0 },
   13829    false,
   13830    nir_op_ishl,
   13831    { &search235_1_0_0_0_0_0_1_0_0_0_0.value, &search235_1_0_0_0_0_0_1_0_0_0_1.value },
   13832    NULL,
   13833 };
   13834 
   13835 #include "compiler/nir/nir_search_helpers.h"
   13836 static const nir_search_variable search235_1_0_0_0_0_0_1_0_0_1_0_0_0_0 = {
   13837    { nir_search_value_variable, 32 },
   13838    0, /* x */
   13839    false,
   13840    nir_type_invalid,
   13841    NULL,
   13842 };
   13843 
   13844 #include "compiler/nir/nir_search_helpers.h"
   13845 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_1_0_0_0_1 = {
   13846    { nir_search_value_constant, 0 },
   13847    nir_type_int, { 0x10 /* 16 */ },
   13848 };
   13849 #include "compiler/nir/nir_search_helpers.h"
   13850 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_1_0_0_0 = {
   13851    { nir_search_value_expression, 0 },
   13852    false,
   13853    nir_op_ishl,
   13854    { &search235_1_0_0_0_0_0_1_0_0_1_0_0_0_0.value, &search235_1_0_0_0_0_0_1_0_0_1_0_0_0_1.value },
   13855    NULL,
   13856 };
   13857 
   13858 #include "compiler/nir/nir_search_helpers.h"
   13859 static const nir_search_variable search235_1_0_0_0_0_0_1_0_0_1_0_0_1_0 = {
   13860    { nir_search_value_variable, 32 },
   13861    0, /* x */
   13862    false,
   13863    nir_type_invalid,
   13864    NULL,
   13865 };
   13866 
   13867 #include "compiler/nir/nir_search_helpers.h"
   13868 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_1_0_0_1_1 = {
   13869    { nir_search_value_constant, 0 },
   13870    nir_type_int, { 0x10 /* 16 */ },
   13871 };
   13872 #include "compiler/nir/nir_search_helpers.h"
   13873 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_1_0_0_1 = {
   13874    { nir_search_value_expression, 0 },
   13875    false,
   13876    nir_op_ushr,
   13877    { &search235_1_0_0_0_0_0_1_0_0_1_0_0_1_0.value, &search235_1_0_0_0_0_0_1_0_0_1_0_0_1_1.value },
   13878    NULL,
   13879 };
   13880 #include "compiler/nir/nir_search_helpers.h"
   13881 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_1_0_0 = {
   13882    { nir_search_value_expression, 0 },
   13883    false,
   13884    nir_op_ior,
   13885    { &search235_1_0_0_0_0_0_1_0_0_1_0_0_0.value, &search235_1_0_0_0_0_0_1_0_0_1_0_0_1.value },
   13886    NULL,
   13887 };
   13888 
   13889 #include "compiler/nir/nir_search_helpers.h"
   13890 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_1_0_1 = {
   13891    { nir_search_value_constant, 0 },
   13892    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   13893 };
   13894 #include "compiler/nir/nir_search_helpers.h"
   13895 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_1_0 = {
   13896    { nir_search_value_expression, 0 },
   13897    false,
   13898    nir_op_iand,
   13899    { &search235_1_0_0_0_0_0_1_0_0_1_0_0.value, &search235_1_0_0_0_0_0_1_0_0_1_0_1.value },
   13900    NULL,
   13901 };
   13902 
   13903 #include "compiler/nir/nir_search_helpers.h"
   13904 static const nir_search_constant search235_1_0_0_0_0_0_1_0_0_1_1 = {
   13905    { nir_search_value_constant, 0 },
   13906    nir_type_int, { 0x8 /* 8 */ },
   13907 };
   13908 #include "compiler/nir/nir_search_helpers.h"
   13909 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0_1 = {
   13910    { nir_search_value_expression, 0 },
   13911    false,
   13912    nir_op_ushr,
   13913    { &search235_1_0_0_0_0_0_1_0_0_1_0.value, &search235_1_0_0_0_0_0_1_0_0_1_1.value },
   13914    NULL,
   13915 };
   13916 #include "compiler/nir/nir_search_helpers.h"
   13917 static const nir_search_expression search235_1_0_0_0_0_0_1_0_0 = {
   13918    { nir_search_value_expression, 0 },
   13919    false,
   13920    nir_op_ior,
   13921    { &search235_1_0_0_0_0_0_1_0_0_0.value, &search235_1_0_0_0_0_0_1_0_0_1.value },
   13922    NULL,
   13923 };
   13924 
   13925 #include "compiler/nir/nir_search_helpers.h"
   13926 static const nir_search_constant search235_1_0_0_0_0_0_1_0_1 = {
   13927    { nir_search_value_constant, 0 },
   13928    nir_type_int, { 0xf0f0f0f0 /* 4042322160 */ },
   13929 };
   13930 #include "compiler/nir/nir_search_helpers.h"
   13931 static const nir_search_expression search235_1_0_0_0_0_0_1_0 = {
   13932    { nir_search_value_expression, 0 },
   13933    false,
   13934    nir_op_iand,
   13935    { &search235_1_0_0_0_0_0_1_0_0.value, &search235_1_0_0_0_0_0_1_0_1.value },
   13936    NULL,
   13937 };
   13938 
   13939 #include "compiler/nir/nir_search_helpers.h"
   13940 static const nir_search_constant search235_1_0_0_0_0_0_1_1 = {
   13941    { nir_search_value_constant, 0 },
   13942    nir_type_int, { 0x4 /* 4 */ },
   13943 };
   13944 #include "compiler/nir/nir_search_helpers.h"
   13945 static const nir_search_expression search235_1_0_0_0_0_0_1 = {
   13946    { nir_search_value_expression, 0 },
   13947    false,
   13948    nir_op_ushr,
   13949    { &search235_1_0_0_0_0_0_1_0.value, &search235_1_0_0_0_0_0_1_1.value },
   13950    NULL,
   13951 };
   13952 #include "compiler/nir/nir_search_helpers.h"
   13953 static const nir_search_expression search235_1_0_0_0_0_0 = {
   13954    { nir_search_value_expression, 0 },
   13955    false,
   13956    nir_op_ior,
   13957    { &search235_1_0_0_0_0_0_0.value, &search235_1_0_0_0_0_0_1.value },
   13958    NULL,
   13959 };
   13960 
   13961 #include "compiler/nir/nir_search_helpers.h"
   13962 static const nir_search_constant search235_1_0_0_0_0_1 = {
   13963    { nir_search_value_constant, 0 },
   13964    nir_type_int, { 0x33333333 /* 858993459 */ },
   13965 };
   13966 #include "compiler/nir/nir_search_helpers.h"
   13967 static const nir_search_expression search235_1_0_0_0_0 = {
   13968    { nir_search_value_expression, 0 },
   13969    false,
   13970    nir_op_iand,
   13971    { &search235_1_0_0_0_0_0.value, &search235_1_0_0_0_0_1.value },
   13972    NULL,
   13973 };
   13974 
   13975 #include "compiler/nir/nir_search_helpers.h"
   13976 static const nir_search_constant search235_1_0_0_0_1 = {
   13977    { nir_search_value_constant, 0 },
   13978    nir_type_int, { 0x2 /* 2 */ },
   13979 };
   13980 #include "compiler/nir/nir_search_helpers.h"
   13981 static const nir_search_expression search235_1_0_0_0 = {
   13982    { nir_search_value_expression, 0 },
   13983    false,
   13984    nir_op_ishl,
   13985    { &search235_1_0_0_0_0.value, &search235_1_0_0_0_1.value },
   13986    NULL,
   13987 };
   13988 
   13989 #include "compiler/nir/nir_search_helpers.h"
   13990 static const nir_search_variable search235_1_0_0_1_0_0_0_0_0_0_0_0_0_0 = {
   13991    { nir_search_value_variable, 32 },
   13992    0, /* x */
   13993    false,
   13994    nir_type_invalid,
   13995    NULL,
   13996 };
   13997 
   13998 #include "compiler/nir/nir_search_helpers.h"
   13999 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_0_0_0_0_1 = {
   14000    { nir_search_value_constant, 0 },
   14001    nir_type_int, { 0x10 /* 16 */ },
   14002 };
   14003 #include "compiler/nir/nir_search_helpers.h"
   14004 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_0_0_0_0 = {
   14005    { nir_search_value_expression, 0 },
   14006    false,
   14007    nir_op_ishl,
   14008    { &search235_1_0_0_1_0_0_0_0_0_0_0_0_0_0.value, &search235_1_0_0_1_0_0_0_0_0_0_0_0_0_1.value },
   14009    NULL,
   14010 };
   14011 
   14012 #include "compiler/nir/nir_search_helpers.h"
   14013 static const nir_search_variable search235_1_0_0_1_0_0_0_0_0_0_0_0_1_0 = {
   14014    { nir_search_value_variable, 32 },
   14015    0, /* x */
   14016    false,
   14017    nir_type_invalid,
   14018    NULL,
   14019 };
   14020 
   14021 #include "compiler/nir/nir_search_helpers.h"
   14022 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_0_0_0_1_1 = {
   14023    { nir_search_value_constant, 0 },
   14024    nir_type_int, { 0x10 /* 16 */ },
   14025 };
   14026 #include "compiler/nir/nir_search_helpers.h"
   14027 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_0_0_0_1 = {
   14028    { nir_search_value_expression, 0 },
   14029    false,
   14030    nir_op_ushr,
   14031    { &search235_1_0_0_1_0_0_0_0_0_0_0_0_1_0.value, &search235_1_0_0_1_0_0_0_0_0_0_0_0_1_1.value },
   14032    NULL,
   14033 };
   14034 #include "compiler/nir/nir_search_helpers.h"
   14035 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_0_0_0 = {
   14036    { nir_search_value_expression, 0 },
   14037    false,
   14038    nir_op_ior,
   14039    { &search235_1_0_0_1_0_0_0_0_0_0_0_0_0.value, &search235_1_0_0_1_0_0_0_0_0_0_0_0_1.value },
   14040    NULL,
   14041 };
   14042 
   14043 #include "compiler/nir/nir_search_helpers.h"
   14044 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_0_0_1 = {
   14045    { nir_search_value_constant, 0 },
   14046    nir_type_int, { 0xff00ff /* 16711935 */ },
   14047 };
   14048 #include "compiler/nir/nir_search_helpers.h"
   14049 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_0_0 = {
   14050    { nir_search_value_expression, 0 },
   14051    false,
   14052    nir_op_iand,
   14053    { &search235_1_0_0_1_0_0_0_0_0_0_0_0.value, &search235_1_0_0_1_0_0_0_0_0_0_0_1.value },
   14054    NULL,
   14055 };
   14056 
   14057 #include "compiler/nir/nir_search_helpers.h"
   14058 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_0_1 = {
   14059    { nir_search_value_constant, 0 },
   14060    nir_type_int, { 0x8 /* 8 */ },
   14061 };
   14062 #include "compiler/nir/nir_search_helpers.h"
   14063 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_0 = {
   14064    { nir_search_value_expression, 0 },
   14065    false,
   14066    nir_op_ishl,
   14067    { &search235_1_0_0_1_0_0_0_0_0_0_0.value, &search235_1_0_0_1_0_0_0_0_0_0_1.value },
   14068    NULL,
   14069 };
   14070 
   14071 #include "compiler/nir/nir_search_helpers.h"
   14072 static const nir_search_variable search235_1_0_0_1_0_0_0_0_0_1_0_0_0_0 = {
   14073    { nir_search_value_variable, 32 },
   14074    0, /* x */
   14075    false,
   14076    nir_type_invalid,
   14077    NULL,
   14078 };
   14079 
   14080 #include "compiler/nir/nir_search_helpers.h"
   14081 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_1_0_0_0_1 = {
   14082    { nir_search_value_constant, 0 },
   14083    nir_type_int, { 0x10 /* 16 */ },
   14084 };
   14085 #include "compiler/nir/nir_search_helpers.h"
   14086 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_1_0_0_0 = {
   14087    { nir_search_value_expression, 0 },
   14088    false,
   14089    nir_op_ishl,
   14090    { &search235_1_0_0_1_0_0_0_0_0_1_0_0_0_0.value, &search235_1_0_0_1_0_0_0_0_0_1_0_0_0_1.value },
   14091    NULL,
   14092 };
   14093 
   14094 #include "compiler/nir/nir_search_helpers.h"
   14095 static const nir_search_variable search235_1_0_0_1_0_0_0_0_0_1_0_0_1_0 = {
   14096    { nir_search_value_variable, 32 },
   14097    0, /* x */
   14098    false,
   14099    nir_type_invalid,
   14100    NULL,
   14101 };
   14102 
   14103 #include "compiler/nir/nir_search_helpers.h"
   14104 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_1_0_0_1_1 = {
   14105    { nir_search_value_constant, 0 },
   14106    nir_type_int, { 0x10 /* 16 */ },
   14107 };
   14108 #include "compiler/nir/nir_search_helpers.h"
   14109 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_1_0_0_1 = {
   14110    { nir_search_value_expression, 0 },
   14111    false,
   14112    nir_op_ushr,
   14113    { &search235_1_0_0_1_0_0_0_0_0_1_0_0_1_0.value, &search235_1_0_0_1_0_0_0_0_0_1_0_0_1_1.value },
   14114    NULL,
   14115 };
   14116 #include "compiler/nir/nir_search_helpers.h"
   14117 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_1_0_0 = {
   14118    { nir_search_value_expression, 0 },
   14119    false,
   14120    nir_op_ior,
   14121    { &search235_1_0_0_1_0_0_0_0_0_1_0_0_0.value, &search235_1_0_0_1_0_0_0_0_0_1_0_0_1.value },
   14122    NULL,
   14123 };
   14124 
   14125 #include "compiler/nir/nir_search_helpers.h"
   14126 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_1_0_1 = {
   14127    { nir_search_value_constant, 0 },
   14128    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   14129 };
   14130 #include "compiler/nir/nir_search_helpers.h"
   14131 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_1_0 = {
   14132    { nir_search_value_expression, 0 },
   14133    false,
   14134    nir_op_iand,
   14135    { &search235_1_0_0_1_0_0_0_0_0_1_0_0.value, &search235_1_0_0_1_0_0_0_0_0_1_0_1.value },
   14136    NULL,
   14137 };
   14138 
   14139 #include "compiler/nir/nir_search_helpers.h"
   14140 static const nir_search_constant search235_1_0_0_1_0_0_0_0_0_1_1 = {
   14141    { nir_search_value_constant, 0 },
   14142    nir_type_int, { 0x8 /* 8 */ },
   14143 };
   14144 #include "compiler/nir/nir_search_helpers.h"
   14145 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0_1 = {
   14146    { nir_search_value_expression, 0 },
   14147    false,
   14148    nir_op_ushr,
   14149    { &search235_1_0_0_1_0_0_0_0_0_1_0.value, &search235_1_0_0_1_0_0_0_0_0_1_1.value },
   14150    NULL,
   14151 };
   14152 #include "compiler/nir/nir_search_helpers.h"
   14153 static const nir_search_expression search235_1_0_0_1_0_0_0_0_0 = {
   14154    { nir_search_value_expression, 0 },
   14155    false,
   14156    nir_op_ior,
   14157    { &search235_1_0_0_1_0_0_0_0_0_0.value, &search235_1_0_0_1_0_0_0_0_0_1.value },
   14158    NULL,
   14159 };
   14160 
   14161 #include "compiler/nir/nir_search_helpers.h"
   14162 static const nir_search_constant search235_1_0_0_1_0_0_0_0_1 = {
   14163    { nir_search_value_constant, 0 },
   14164    nir_type_int, { 0xf0f0f0f /* 252645135 */ },
   14165 };
   14166 #include "compiler/nir/nir_search_helpers.h"
   14167 static const nir_search_expression search235_1_0_0_1_0_0_0_0 = {
   14168    { nir_search_value_expression, 0 },
   14169    false,
   14170    nir_op_iand,
   14171    { &search235_1_0_0_1_0_0_0_0_0.value, &search235_1_0_0_1_0_0_0_0_1.value },
   14172    NULL,
   14173 };
   14174 
   14175 #include "compiler/nir/nir_search_helpers.h"
   14176 static const nir_search_constant search235_1_0_0_1_0_0_0_1 = {
   14177    { nir_search_value_constant, 0 },
   14178    nir_type_int, { 0x4 /* 4 */ },
   14179 };
   14180 #include "compiler/nir/nir_search_helpers.h"
   14181 static const nir_search_expression search235_1_0_0_1_0_0_0 = {
   14182    { nir_search_value_expression, 0 },
   14183    false,
   14184    nir_op_ishl,
   14185    { &search235_1_0_0_1_0_0_0_0.value, &search235_1_0_0_1_0_0_0_1.value },
   14186    NULL,
   14187 };
   14188 
   14189 #include "compiler/nir/nir_search_helpers.h"
   14190 static const nir_search_variable search235_1_0_0_1_0_0_1_0_0_0_0_0_0_0 = {
   14191    { nir_search_value_variable, 32 },
   14192    0, /* x */
   14193    false,
   14194    nir_type_invalid,
   14195    NULL,
   14196 };
   14197 
   14198 #include "compiler/nir/nir_search_helpers.h"
   14199 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_0_0_0_0_1 = {
   14200    { nir_search_value_constant, 0 },
   14201    nir_type_int, { 0x10 /* 16 */ },
   14202 };
   14203 #include "compiler/nir/nir_search_helpers.h"
   14204 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_0_0_0_0 = {
   14205    { nir_search_value_expression, 0 },
   14206    false,
   14207    nir_op_ishl,
   14208    { &search235_1_0_0_1_0_0_1_0_0_0_0_0_0_0.value, &search235_1_0_0_1_0_0_1_0_0_0_0_0_0_1.value },
   14209    NULL,
   14210 };
   14211 
   14212 #include "compiler/nir/nir_search_helpers.h"
   14213 static const nir_search_variable search235_1_0_0_1_0_0_1_0_0_0_0_0_1_0 = {
   14214    { nir_search_value_variable, 32 },
   14215    0, /* x */
   14216    false,
   14217    nir_type_invalid,
   14218    NULL,
   14219 };
   14220 
   14221 #include "compiler/nir/nir_search_helpers.h"
   14222 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_0_0_0_1_1 = {
   14223    { nir_search_value_constant, 0 },
   14224    nir_type_int, { 0x10 /* 16 */ },
   14225 };
   14226 #include "compiler/nir/nir_search_helpers.h"
   14227 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_0_0_0_1 = {
   14228    { nir_search_value_expression, 0 },
   14229    false,
   14230    nir_op_ushr,
   14231    { &search235_1_0_0_1_0_0_1_0_0_0_0_0_1_0.value, &search235_1_0_0_1_0_0_1_0_0_0_0_0_1_1.value },
   14232    NULL,
   14233 };
   14234 #include "compiler/nir/nir_search_helpers.h"
   14235 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_0_0_0 = {
   14236    { nir_search_value_expression, 0 },
   14237    false,
   14238    nir_op_ior,
   14239    { &search235_1_0_0_1_0_0_1_0_0_0_0_0_0.value, &search235_1_0_0_1_0_0_1_0_0_0_0_0_1.value },
   14240    NULL,
   14241 };
   14242 
   14243 #include "compiler/nir/nir_search_helpers.h"
   14244 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_0_0_1 = {
   14245    { nir_search_value_constant, 0 },
   14246    nir_type_int, { 0xff00ff /* 16711935 */ },
   14247 };
   14248 #include "compiler/nir/nir_search_helpers.h"
   14249 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_0_0 = {
   14250    { nir_search_value_expression, 0 },
   14251    false,
   14252    nir_op_iand,
   14253    { &search235_1_0_0_1_0_0_1_0_0_0_0_0.value, &search235_1_0_0_1_0_0_1_0_0_0_0_1.value },
   14254    NULL,
   14255 };
   14256 
   14257 #include "compiler/nir/nir_search_helpers.h"
   14258 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_0_1 = {
   14259    { nir_search_value_constant, 0 },
   14260    nir_type_int, { 0x8 /* 8 */ },
   14261 };
   14262 #include "compiler/nir/nir_search_helpers.h"
   14263 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_0 = {
   14264    { nir_search_value_expression, 0 },
   14265    false,
   14266    nir_op_ishl,
   14267    { &search235_1_0_0_1_0_0_1_0_0_0_0.value, &search235_1_0_0_1_0_0_1_0_0_0_1.value },
   14268    NULL,
   14269 };
   14270 
   14271 #include "compiler/nir/nir_search_helpers.h"
   14272 static const nir_search_variable search235_1_0_0_1_0_0_1_0_0_1_0_0_0_0 = {
   14273    { nir_search_value_variable, 32 },
   14274    0, /* x */
   14275    false,
   14276    nir_type_invalid,
   14277    NULL,
   14278 };
   14279 
   14280 #include "compiler/nir/nir_search_helpers.h"
   14281 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_1_0_0_0_1 = {
   14282    { nir_search_value_constant, 0 },
   14283    nir_type_int, { 0x10 /* 16 */ },
   14284 };
   14285 #include "compiler/nir/nir_search_helpers.h"
   14286 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_1_0_0_0 = {
   14287    { nir_search_value_expression, 0 },
   14288    false,
   14289    nir_op_ishl,
   14290    { &search235_1_0_0_1_0_0_1_0_0_1_0_0_0_0.value, &search235_1_0_0_1_0_0_1_0_0_1_0_0_0_1.value },
   14291    NULL,
   14292 };
   14293 
   14294 #include "compiler/nir/nir_search_helpers.h"
   14295 static const nir_search_variable search235_1_0_0_1_0_0_1_0_0_1_0_0_1_0 = {
   14296    { nir_search_value_variable, 32 },
   14297    0, /* x */
   14298    false,
   14299    nir_type_invalid,
   14300    NULL,
   14301 };
   14302 
   14303 #include "compiler/nir/nir_search_helpers.h"
   14304 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_1_0_0_1_1 = {
   14305    { nir_search_value_constant, 0 },
   14306    nir_type_int, { 0x10 /* 16 */ },
   14307 };
   14308 #include "compiler/nir/nir_search_helpers.h"
   14309 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_1_0_0_1 = {
   14310    { nir_search_value_expression, 0 },
   14311    false,
   14312    nir_op_ushr,
   14313    { &search235_1_0_0_1_0_0_1_0_0_1_0_0_1_0.value, &search235_1_0_0_1_0_0_1_0_0_1_0_0_1_1.value },
   14314    NULL,
   14315 };
   14316 #include "compiler/nir/nir_search_helpers.h"
   14317 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_1_0_0 = {
   14318    { nir_search_value_expression, 0 },
   14319    false,
   14320    nir_op_ior,
   14321    { &search235_1_0_0_1_0_0_1_0_0_1_0_0_0.value, &search235_1_0_0_1_0_0_1_0_0_1_0_0_1.value },
   14322    NULL,
   14323 };
   14324 
   14325 #include "compiler/nir/nir_search_helpers.h"
   14326 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_1_0_1 = {
   14327    { nir_search_value_constant, 0 },
   14328    nir_type_int, { 0xff00ff00 /* 4278255360 */ },
   14329 };
   14330 #include "compiler/nir/nir_search_helpers.h"
   14331 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_1_0 = {
   14332    { nir_search_value_expression, 0 },
   14333    false,
   14334    nir_op_iand,
   14335    { &search235_1_0_0_1_0_0_1_0_0_1_0_0.value, &search235_1_0_0_1_0_0_1_0_0_1_0_1.value },
   14336    NULL,
   14337 };
   14338 
   14339 #include "compiler/nir/nir_search_helpers.h"
   14340 static const nir_search_constant search235_1_0_0_1_0_0_1_0_0_1_1 = {
   14341    { nir_search_value_constant, 0 },
   14342    nir_type_int, { 0x8 /* 8 */ },
   14343 };
   14344 #include "compiler/nir/nir_search_helpers.h"
   14345 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0_1 = {
   14346    { nir_search_value_expression, 0 },
   14347    false,
   14348    nir_op_ushr,
   14349    { &search235_1_0_0_1_0_0_1_0_0_1_0.value, &search235_1_0_0_1_0_0_1_0_0_1_1.value },
   14350    NULL,
   14351 };
   14352 #include "compiler/nir/nir_search_helpers.h"
   14353 static const nir_search_expression search235_1_0_0_1_0_0_1_0_0 = {
   14354    { nir_search_value_expression, 0 },
   14355    false,
   14356    nir_op_ior,
   14357    { &search235_1_0_0_1_0_0_1_0_0_0.value, &search235_1_0_0_1_0_0_1_0_0_1.value },
   14358    NULL,
   14359 };
   14360 
   14361 #include "compiler/nir/nir_search_helpers.h"
   14362 static const nir_search_constant search235_1_0_0_1_0_0_1_0_1 = {
   14363    { nir_search_value_constant, 0 },
   14364    nir_type_int, { 0xf0f0f0f0 /* 4042322160 */ },
   14365 };
   14366 #include "compiler/nir/nir_search_helpers.h"
   14367 static const nir_search_expression search235_1_0_0_1_0_0_1_0 = {
   14368    { nir_search_value_expression, 0 },
   14369    false,
   14370    nir_op_iand,
   14371    { &search235_1_0_0_1_0_0_1_0_0.value, &search235_1_0_0_1_0_0_1_0_1.value },
   14372    NULL,
   14373 };
   14374 
   14375 #include "compiler/nir/nir_search_helpers.h"
   14376 static const nir_search_constant search235_1_0_0_1_0_0_1_1 = {
   14377    { nir_search_value_constant, 0 },
   14378    nir_type_int, { 0x4 /* 4 */ },
   14379 };
   14380 #include "compiler/nir/nir_search_helpers.h"
   14381 static const nir_search_expression search235_1_0_0_1_0_0_1 = {
   14382    { nir_search_value_expression, 0 },
   14383    false,
   14384    nir_op_ushr,
   14385    { &search235_1_0_0_1_0_0_1_0.value, &search235_1_0_0_1_0_0_1_1.value },
   14386    NULL,
   14387 };
   14388 #include "compiler/nir/nir_search_helpers.h"
   14389 static const nir_search_expression search235_1_0_0_1_0_0 = {
   14390    { nir_search_value_expression, 0 },
   14391    false,
   14392    nir_op_ior,
   14393    { &search235_1_0_0_1_0_0_0.value, &search235_1_0_0_1_0_0_1.value },
   14394    NULL,
   14395 };
   14396 
   14397 #include "compiler/nir/nir_search_helpers.h"
   14398 static const nir_search_constant search235_1_0_0_1_0_1 = {
   14399    { nir_search_value_constant, 0 },
   14400    nir_type_int, { 0xcccccccc /* 3435973836 */ },
   14401 };
   14402 #include "compiler/nir/nir_search_helpers.h"
   14403 static const nir_search_expression search235_1_0_0_1_0 = {
   14404    { nir_search_value_expression, 0 },
   14405    false,
   14406    nir_op_iand,
   14407    { &search235_1_0_0_1_0_0.value, &search235_1_0_0_1_0_1.value },
   14408    NULL,
   14409 };
   14410 
   14411 #include "compiler/nir/nir_search_helpers.h"
   14412 static const nir_search_constant search235_1_0_0_1_1 = {
   14413    { nir_search_value_constant, 0 },
   14414    nir_type_int, { 0x2 /* 2 */ },
   14415 };
   14416 #include "compiler/nir/nir_search_helpers.h"
   14417 static const nir_search_expression search235_1_0_0_1 = {
   14418    { nir_search_value_expression, 0 },
   14419    false,
   14420    nir_op_ushr,
   14421    { &search235_1_0_0_1_0.value, &search235_1_0_0_1_1.value },
   14422    NULL,
   14423 };
   14424 #include "compiler/nir/nir_search_helpers.h"
   14425 static const nir_search_expression search235_1_0_0 = {
   14426    { nir_search_value_expression, 0 },
   14427    false,
   14428    nir_op_ior,
   14429    { &search235_1_0_0_0.value, &search235_1_0_0_1.value },
   14430    NULL,
   14431 };
   14432 
   14433 #include "compiler/nir/nir_search_helpers.h"
   14434 static const nir_search_constant search235_1_0_1 = {
   14435    { nir_search_value_constant, 0 },
   14436    nir_type_int, { 0xaaaaaaaa /* 2863311530 */ },
   14437 };
   14438 #include "compiler/nir/nir_search_helpers.h"
   14439 static const nir_search_expression search235_1_0 = {
   14440    { nir_search_value_expression, 0 },
   14441    false,
   14442    nir_op_iand,
   14443    { &search235_1_0_0.value, &search235_1_0_1.value },
   14444    NULL,
   14445 };
   14446 
   14447 #include "compiler/nir/nir_search_helpers.h"
   14448 static const nir_search_constant search235_1_1 = {
   14449    { nir_search_value_constant, 0 },
   14450    nir_type_int, { 0x1 /* 1 */ },
   14451 };
   14452 #include "compiler/nir/nir_search_helpers.h"
   14453 static const nir_search_expression search235_1 = {
   14454    { nir_search_value_expression, 0 },
   14455    false,
   14456    nir_op_ushr,
   14457    { &search235_1_0.value, &search235_1_1.value },
   14458    NULL,
   14459 };
   14460 #include "compiler/nir/nir_search_helpers.h"
   14461 static const nir_search_expression search235 = {
   14462    { nir_search_value_expression, 0 },
   14463    false,
   14464    nir_op_ior,
   14465    { &search235_0.value, &search235_1.value },
   14466    NULL,
   14467 };
   14468 
   14469 #include "compiler/nir/nir_search_helpers.h"
   14470 static const nir_search_variable replace235_0 = {
   14471    { nir_search_value_variable, 0 },
   14472    0, /* x */
   14473    false,
   14474    nir_type_invalid,
   14475    NULL,
   14476 };
   14477 #include "compiler/nir/nir_search_helpers.h"
   14478 static const nir_search_expression replace235 = {
   14479    { nir_search_value_expression, 0 },
   14480    false,
   14481    nir_op_bitfield_reverse,
   14482    { &replace235_0.value },
   14483    NULL,
   14484 };
   14485 
   14486 static const struct transform nir_opt_algebraic_ior_xforms[] = {
   14487    { &search94, &replace94.value, 0 },
   14488    { &search95, &replace95.value, 0 },
   14489    { &search96, &replace96.value, 0 },
   14490    { &search97, &replace97.value, 0 },
   14491    { &search125, &replace125.value, 0 },
   14492    { &search126, &replace126.value, 0 },
   14493    { &search127, &replace127.value, 0 },
   14494    { &search133, &replace133.value, 0 },
   14495    { &search235, &replace235.value, 0 },
   14496 };
   14497 
   14498 #include "compiler/nir/nir_search_helpers.h"
   14499 static const nir_search_variable search197_0 = {
   14500    { nir_search_value_variable, 0 },
   14501    0, /* a */
   14502    false,
   14503    nir_type_invalid,
   14504    NULL,
   14505 };
   14506 
   14507 #include "compiler/nir/nir_search_helpers.h"
   14508 static const nir_search_constant search197_1 = {
   14509    { nir_search_value_constant, 0 },
   14510    nir_type_int, { 0x0 /* 0 */ },
   14511 };
   14512 #include "compiler/nir/nir_search_helpers.h"
   14513 static const nir_search_expression search197 = {
   14514    { nir_search_value_expression, 0 },
   14515    false,
   14516    nir_op_ussub_4x8,
   14517    { &search197_0.value, &search197_1.value },
   14518    NULL,
   14519 };
   14520 
   14521 #include "compiler/nir/nir_search_helpers.h"
   14522 static const nir_search_variable replace197 = {
   14523    { nir_search_value_variable, 0 },
   14524    0, /* a */
   14525    false,
   14526    nir_type_invalid,
   14527    NULL,
   14528 };
   14529 
   14530 #include "compiler/nir/nir_search_helpers.h"
   14531 static const nir_search_variable search198_0 = {
   14532    { nir_search_value_variable, 0 },
   14533    0, /* a */
   14534    false,
   14535    nir_type_invalid,
   14536    NULL,
   14537 };
   14538 
   14539 #include "compiler/nir/nir_search_helpers.h"
   14540 static const nir_search_constant search198_1 = {
   14541    { nir_search_value_constant, 0 },
   14542    nir_type_int, { -0x1 /* -1 */ },
   14543 };
   14544 #include "compiler/nir/nir_search_helpers.h"
   14545 static const nir_search_expression search198 = {
   14546    { nir_search_value_expression, 0 },
   14547    false,
   14548    nir_op_ussub_4x8,
   14549    { &search198_0.value, &search198_1.value },
   14550    NULL,
   14551 };
   14552 
   14553 #include "compiler/nir/nir_search_helpers.h"
   14554 static const nir_search_constant replace198 = {
   14555    { nir_search_value_constant, 0 },
   14556    nir_type_int, { 0x0 /* 0 */ },
   14557 };
   14558 
   14559 static const struct transform nir_opt_algebraic_ussub_4x8_xforms[] = {
   14560    { &search197, &replace197.value, 0 },
   14561    { &search198, &replace198.value, 0 },
   14562 };
   14563 
   14564 #include "compiler/nir/nir_search_helpers.h"
   14565 static const nir_search_variable search232_0 = {
   14566    { nir_search_value_variable, 0 },
   14567    0, /* v */
   14568    false,
   14569    nir_type_invalid,
   14570    NULL,
   14571 };
   14572 #include "compiler/nir/nir_search_helpers.h"
   14573 static const nir_search_expression search232 = {
   14574    { nir_search_value_expression, 0 },
   14575    false,
   14576    nir_op_unpack_snorm_4x8,
   14577    { &search232_0.value },
   14578    NULL,
   14579 };
   14580 
   14581 #include "compiler/nir/nir_search_helpers.h"
   14582 static const nir_search_constant replace232_0 = {
   14583    { nir_search_value_constant, 0 },
   14584    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   14585 };
   14586 
   14587 #include "compiler/nir/nir_search_helpers.h"
   14588 static const nir_search_constant replace232_1_0 = {
   14589    { nir_search_value_constant, 0 },
   14590    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   14591 };
   14592 
   14593 #include "compiler/nir/nir_search_helpers.h"
   14594 static const nir_search_variable replace232_1_1_0_0_0_0 = {
   14595    { nir_search_value_variable, 0 },
   14596    0, /* v */
   14597    false,
   14598    nir_type_invalid,
   14599    NULL,
   14600 };
   14601 
   14602 #include "compiler/nir/nir_search_helpers.h"
   14603 static const nir_search_constant replace232_1_1_0_0_0_1 = {
   14604    { nir_search_value_constant, 0 },
   14605    nir_type_int, { 0x0 /* 0 */ },
   14606 };
   14607 #include "compiler/nir/nir_search_helpers.h"
   14608 static const nir_search_expression replace232_1_1_0_0_0 = {
   14609    { nir_search_value_expression, 0 },
   14610    false,
   14611    nir_op_extract_i8,
   14612    { &replace232_1_1_0_0_0_0.value, &replace232_1_1_0_0_0_1.value },
   14613    NULL,
   14614 };
   14615 
   14616 #include "compiler/nir/nir_search_helpers.h"
   14617 static const nir_search_variable replace232_1_1_0_0_1_0 = {
   14618    { nir_search_value_variable, 0 },
   14619    0, /* v */
   14620    false,
   14621    nir_type_invalid,
   14622    NULL,
   14623 };
   14624 
   14625 #include "compiler/nir/nir_search_helpers.h"
   14626 static const nir_search_constant replace232_1_1_0_0_1_1 = {
   14627    { nir_search_value_constant, 0 },
   14628    nir_type_int, { 0x1 /* 1 */ },
   14629 };
   14630 #include "compiler/nir/nir_search_helpers.h"
   14631 static const nir_search_expression replace232_1_1_0_0_1 = {
   14632    { nir_search_value_expression, 0 },
   14633    false,
   14634    nir_op_extract_i8,
   14635    { &replace232_1_1_0_0_1_0.value, &replace232_1_1_0_0_1_1.value },
   14636    NULL,
   14637 };
   14638 
   14639 #include "compiler/nir/nir_search_helpers.h"
   14640 static const nir_search_variable replace232_1_1_0_0_2_0 = {
   14641    { nir_search_value_variable, 0 },
   14642    0, /* v */
   14643    false,
   14644    nir_type_invalid,
   14645    NULL,
   14646 };
   14647 
   14648 #include "compiler/nir/nir_search_helpers.h"
   14649 static const nir_search_constant replace232_1_1_0_0_2_1 = {
   14650    { nir_search_value_constant, 0 },
   14651    nir_type_int, { 0x2 /* 2 */ },
   14652 };
   14653 #include "compiler/nir/nir_search_helpers.h"
   14654 static const nir_search_expression replace232_1_1_0_0_2 = {
   14655    { nir_search_value_expression, 0 },
   14656    false,
   14657    nir_op_extract_i8,
   14658    { &replace232_1_1_0_0_2_0.value, &replace232_1_1_0_0_2_1.value },
   14659    NULL,
   14660 };
   14661 
   14662 #include "compiler/nir/nir_search_helpers.h"
   14663 static const nir_search_variable replace232_1_1_0_0_3_0 = {
   14664    { nir_search_value_variable, 0 },
   14665    0, /* v */
   14666    false,
   14667    nir_type_invalid,
   14668    NULL,
   14669 };
   14670 
   14671 #include "compiler/nir/nir_search_helpers.h"
   14672 static const nir_search_constant replace232_1_1_0_0_3_1 = {
   14673    { nir_search_value_constant, 0 },
   14674    nir_type_int, { 0x3 /* 3 */ },
   14675 };
   14676 #include "compiler/nir/nir_search_helpers.h"
   14677 static const nir_search_expression replace232_1_1_0_0_3 = {
   14678    { nir_search_value_expression, 0 },
   14679    false,
   14680    nir_op_extract_i8,
   14681    { &replace232_1_1_0_0_3_0.value, &replace232_1_1_0_0_3_1.value },
   14682    NULL,
   14683 };
   14684 #include "compiler/nir/nir_search_helpers.h"
   14685 static const nir_search_expression replace232_1_1_0_0 = {
   14686    { nir_search_value_expression, 0 },
   14687    false,
   14688    nir_op_vec4,
   14689    { &replace232_1_1_0_0_0.value, &replace232_1_1_0_0_1.value, &replace232_1_1_0_0_2.value, &replace232_1_1_0_0_3.value },
   14690    NULL,
   14691 };
   14692 #include "compiler/nir/nir_search_helpers.h"
   14693 static const nir_search_expression replace232_1_1_0 = {
   14694    { nir_search_value_expression, 0 },
   14695    false,
   14696    nir_op_i2f,
   14697    { &replace232_1_1_0_0.value },
   14698    NULL,
   14699 };
   14700 
   14701 #include "compiler/nir/nir_search_helpers.h"
   14702 static const nir_search_constant replace232_1_1_1 = {
   14703    { nir_search_value_constant, 0 },
   14704    nir_type_float, { 0x405fc00000000000 /* 127.0 */ },
   14705 };
   14706 #include "compiler/nir/nir_search_helpers.h"
   14707 static const nir_search_expression replace232_1_1 = {
   14708    { nir_search_value_expression, 0 },
   14709    false,
   14710    nir_op_fdiv,
   14711    { &replace232_1_1_0.value, &replace232_1_1_1.value },
   14712    NULL,
   14713 };
   14714 #include "compiler/nir/nir_search_helpers.h"
   14715 static const nir_search_expression replace232_1 = {
   14716    { nir_search_value_expression, 0 },
   14717    false,
   14718    nir_op_fmax,
   14719    { &replace232_1_0.value, &replace232_1_1.value },
   14720    NULL,
   14721 };
   14722 #include "compiler/nir/nir_search_helpers.h"
   14723 static const nir_search_expression replace232 = {
   14724    { nir_search_value_expression, 0 },
   14725    false,
   14726    nir_op_fmin,
   14727    { &replace232_0.value, &replace232_1.value },
   14728    NULL,
   14729 };
   14730 
   14731 static const struct transform nir_opt_algebraic_unpack_snorm_4x8_xforms[] = {
   14732    { &search232, &replace232.value, 36 },
   14733 };
   14734 
   14735 #include "compiler/nir/nir_search_helpers.h"
   14736 static const nir_search_variable search215_0 = {
   14737    { nir_search_value_variable, 0 },
   14738    0, /* a */
   14739    false,
   14740    nir_type_invalid,
   14741    NULL,
   14742 };
   14743 
   14744 #include "compiler/nir/nir_search_helpers.h"
   14745 static const nir_search_variable search215_1 = {
   14746    { nir_search_value_variable, 0 },
   14747    1, /* b */
   14748    false,
   14749    nir_type_invalid,
   14750    NULL,
   14751 };
   14752 #include "compiler/nir/nir_search_helpers.h"
   14753 static const nir_search_expression search215 = {
   14754    { nir_search_value_expression, 0 },
   14755    false,
   14756    nir_op_frem,
   14757    { &search215_0.value, &search215_1.value },
   14758    NULL,
   14759 };
   14760 
   14761 #include "compiler/nir/nir_search_helpers.h"
   14762 static const nir_search_variable replace215_0 = {
   14763    { nir_search_value_variable, 0 },
   14764    0, /* a */
   14765    false,
   14766    nir_type_invalid,
   14767    NULL,
   14768 };
   14769 
   14770 #include "compiler/nir/nir_search_helpers.h"
   14771 static const nir_search_variable replace215_1_0 = {
   14772    { nir_search_value_variable, 0 },
   14773    1, /* b */
   14774    false,
   14775    nir_type_invalid,
   14776    NULL,
   14777 };
   14778 
   14779 #include "compiler/nir/nir_search_helpers.h"
   14780 static const nir_search_variable replace215_1_1_0_0 = {
   14781    { nir_search_value_variable, 0 },
   14782    0, /* a */
   14783    false,
   14784    nir_type_invalid,
   14785    NULL,
   14786 };
   14787 
   14788 #include "compiler/nir/nir_search_helpers.h"
   14789 static const nir_search_variable replace215_1_1_0_1 = {
   14790    { nir_search_value_variable, 0 },
   14791    1, /* b */
   14792    false,
   14793    nir_type_invalid,
   14794    NULL,
   14795 };
   14796 #include "compiler/nir/nir_search_helpers.h"
   14797 static const nir_search_expression replace215_1_1_0 = {
   14798    { nir_search_value_expression, 0 },
   14799    false,
   14800    nir_op_fdiv,
   14801    { &replace215_1_1_0_0.value, &replace215_1_1_0_1.value },
   14802    NULL,
   14803 };
   14804 #include "compiler/nir/nir_search_helpers.h"
   14805 static const nir_search_expression replace215_1_1 = {
   14806    { nir_search_value_expression, 0 },
   14807    false,
   14808    nir_op_ftrunc,
   14809    { &replace215_1_1_0.value },
   14810    NULL,
   14811 };
   14812 #include "compiler/nir/nir_search_helpers.h"
   14813 static const nir_search_expression replace215_1 = {
   14814    { nir_search_value_expression, 0 },
   14815    false,
   14816    nir_op_fmul,
   14817    { &replace215_1_0.value, &replace215_1_1.value },
   14818    NULL,
   14819 };
   14820 #include "compiler/nir/nir_search_helpers.h"
   14821 static const nir_search_expression replace215 = {
   14822    { nir_search_value_expression, 0 },
   14823    false,
   14824    nir_op_fsub,
   14825    { &replace215_0.value, &replace215_1.value },
   14826    NULL,
   14827 };
   14828 
   14829 static const struct transform nir_opt_algebraic_frem_xforms[] = {
   14830    { &search215, &replace215.value, 21 },
   14831 };
   14832 
   14833 #include "compiler/nir/nir_search_helpers.h"
   14834 static const nir_search_variable search229_0 = {
   14835    { nir_search_value_variable, 0 },
   14836    0, /* v */
   14837    false,
   14838    nir_type_invalid,
   14839    NULL,
   14840 };
   14841 #include "compiler/nir/nir_search_helpers.h"
   14842 static const nir_search_expression search229 = {
   14843    { nir_search_value_expression, 0 },
   14844    false,
   14845    nir_op_unpack_unorm_2x16,
   14846    { &search229_0.value },
   14847    NULL,
   14848 };
   14849 
   14850 #include "compiler/nir/nir_search_helpers.h"
   14851 static const nir_search_variable replace229_0_0_0_0 = {
   14852    { nir_search_value_variable, 0 },
   14853    0, /* v */
   14854    false,
   14855    nir_type_invalid,
   14856    NULL,
   14857 };
   14858 
   14859 #include "compiler/nir/nir_search_helpers.h"
   14860 static const nir_search_constant replace229_0_0_0_1 = {
   14861    { nir_search_value_constant, 0 },
   14862    nir_type_int, { 0x0 /* 0 */ },
   14863 };
   14864 #include "compiler/nir/nir_search_helpers.h"
   14865 static const nir_search_expression replace229_0_0_0 = {
   14866    { nir_search_value_expression, 0 },
   14867    false,
   14868    nir_op_extract_u16,
   14869    { &replace229_0_0_0_0.value, &replace229_0_0_0_1.value },
   14870    NULL,
   14871 };
   14872 
   14873 #include "compiler/nir/nir_search_helpers.h"
   14874 static const nir_search_variable replace229_0_0_1_0 = {
   14875    { nir_search_value_variable, 0 },
   14876    0, /* v */
   14877    false,
   14878    nir_type_invalid,
   14879    NULL,
   14880 };
   14881 
   14882 #include "compiler/nir/nir_search_helpers.h"
   14883 static const nir_search_constant replace229_0_0_1_1 = {
   14884    { nir_search_value_constant, 0 },
   14885    nir_type_int, { 0x1 /* 1 */ },
   14886 };
   14887 #include "compiler/nir/nir_search_helpers.h"
   14888 static const nir_search_expression replace229_0_0_1 = {
   14889    { nir_search_value_expression, 0 },
   14890    false,
   14891    nir_op_extract_u16,
   14892    { &replace229_0_0_1_0.value, &replace229_0_0_1_1.value },
   14893    NULL,
   14894 };
   14895 #include "compiler/nir/nir_search_helpers.h"
   14896 static const nir_search_expression replace229_0_0 = {
   14897    { nir_search_value_expression, 0 },
   14898    false,
   14899    nir_op_vec2,
   14900    { &replace229_0_0_0.value, &replace229_0_0_1.value },
   14901    NULL,
   14902 };
   14903 #include "compiler/nir/nir_search_helpers.h"
   14904 static const nir_search_expression replace229_0 = {
   14905    { nir_search_value_expression, 0 },
   14906    false,
   14907    nir_op_u2f,
   14908    { &replace229_0_0.value },
   14909    NULL,
   14910 };
   14911 
   14912 #include "compiler/nir/nir_search_helpers.h"
   14913 static const nir_search_constant replace229_1 = {
   14914    { nir_search_value_constant, 0 },
   14915    nir_type_float, { 0x40efffe000000000 /* 65535.0 */ },
   14916 };
   14917 #include "compiler/nir/nir_search_helpers.h"
   14918 static const nir_search_expression replace229 = {
   14919    { nir_search_value_expression, 0 },
   14920    false,
   14921    nir_op_fdiv,
   14922    { &replace229_0.value, &replace229_1.value },
   14923    NULL,
   14924 };
   14925 
   14926 static const struct transform nir_opt_algebraic_unpack_unorm_2x16_xforms[] = {
   14927    { &search229, &replace229.value, 33 },
   14928 };
   14929 
   14930 #include "compiler/nir/nir_search_helpers.h"
   14931 static const nir_search_variable search231_0 = {
   14932    { nir_search_value_variable, 0 },
   14933    0, /* v */
   14934    false,
   14935    nir_type_invalid,
   14936    NULL,
   14937 };
   14938 #include "compiler/nir/nir_search_helpers.h"
   14939 static const nir_search_expression search231 = {
   14940    { nir_search_value_expression, 0 },
   14941    false,
   14942    nir_op_unpack_snorm_2x16,
   14943    { &search231_0.value },
   14944    NULL,
   14945 };
   14946 
   14947 #include "compiler/nir/nir_search_helpers.h"
   14948 static const nir_search_constant replace231_0 = {
   14949    { nir_search_value_constant, 0 },
   14950    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   14951 };
   14952 
   14953 #include "compiler/nir/nir_search_helpers.h"
   14954 static const nir_search_constant replace231_1_0 = {
   14955    { nir_search_value_constant, 0 },
   14956    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   14957 };
   14958 
   14959 #include "compiler/nir/nir_search_helpers.h"
   14960 static const nir_search_variable replace231_1_1_0_0_0_0 = {
   14961    { nir_search_value_variable, 0 },
   14962    0, /* v */
   14963    false,
   14964    nir_type_invalid,
   14965    NULL,
   14966 };
   14967 
   14968 #include "compiler/nir/nir_search_helpers.h"
   14969 static const nir_search_constant replace231_1_1_0_0_0_1 = {
   14970    { nir_search_value_constant, 0 },
   14971    nir_type_int, { 0x0 /* 0 */ },
   14972 };
   14973 #include "compiler/nir/nir_search_helpers.h"
   14974 static const nir_search_expression replace231_1_1_0_0_0 = {
   14975    { nir_search_value_expression, 0 },
   14976    false,
   14977    nir_op_extract_i16,
   14978    { &replace231_1_1_0_0_0_0.value, &replace231_1_1_0_0_0_1.value },
   14979    NULL,
   14980 };
   14981 
   14982 #include "compiler/nir/nir_search_helpers.h"
   14983 static const nir_search_variable replace231_1_1_0_0_1_0 = {
   14984    { nir_search_value_variable, 0 },
   14985    0, /* v */
   14986    false,
   14987    nir_type_invalid,
   14988    NULL,
   14989 };
   14990 
   14991 #include "compiler/nir/nir_search_helpers.h"
   14992 static const nir_search_constant replace231_1_1_0_0_1_1 = {
   14993    { nir_search_value_constant, 0 },
   14994    nir_type_int, { 0x1 /* 1 */ },
   14995 };
   14996 #include "compiler/nir/nir_search_helpers.h"
   14997 static const nir_search_expression replace231_1_1_0_0_1 = {
   14998    { nir_search_value_expression, 0 },
   14999    false,
   15000    nir_op_extract_i16,
   15001    { &replace231_1_1_0_0_1_0.value, &replace231_1_1_0_0_1_1.value },
   15002    NULL,
   15003 };
   15004 #include "compiler/nir/nir_search_helpers.h"
   15005 static const nir_search_expression replace231_1_1_0_0 = {
   15006    { nir_search_value_expression, 0 },
   15007    false,
   15008    nir_op_vec2,
   15009    { &replace231_1_1_0_0_0.value, &replace231_1_1_0_0_1.value },
   15010    NULL,
   15011 };
   15012 #include "compiler/nir/nir_search_helpers.h"
   15013 static const nir_search_expression replace231_1_1_0 = {
   15014    { nir_search_value_expression, 0 },
   15015    false,
   15016    nir_op_i2f,
   15017    { &replace231_1_1_0_0.value },
   15018    NULL,
   15019 };
   15020 
   15021 #include "compiler/nir/nir_search_helpers.h"
   15022 static const nir_search_constant replace231_1_1_1 = {
   15023    { nir_search_value_constant, 0 },
   15024    nir_type_float, { 0x40dfffc000000000 /* 32767.0 */ },
   15025 };
   15026 #include "compiler/nir/nir_search_helpers.h"
   15027 static const nir_search_expression replace231_1_1 = {
   15028    { nir_search_value_expression, 0 },
   15029    false,
   15030    nir_op_fdiv,
   15031    { &replace231_1_1_0.value, &replace231_1_1_1.value },
   15032    NULL,
   15033 };
   15034 #include "compiler/nir/nir_search_helpers.h"
   15035 static const nir_search_expression replace231_1 = {
   15036    { nir_search_value_expression, 0 },
   15037    false,
   15038    nir_op_fmax,
   15039    { &replace231_1_0.value, &replace231_1_1.value },
   15040    NULL,
   15041 };
   15042 #include "compiler/nir/nir_search_helpers.h"
   15043 static const nir_search_expression replace231 = {
   15044    { nir_search_value_expression, 0 },
   15045    false,
   15046    nir_op_fmin,
   15047    { &replace231_0.value, &replace231_1.value },
   15048    NULL,
   15049 };
   15050 
   15051 static const struct transform nir_opt_algebraic_unpack_snorm_2x16_xforms[] = {
   15052    { &search231, &replace231.value, 35 },
   15053 };
   15054 
   15055 #include "compiler/nir/nir_search_helpers.h"
   15056 static const nir_search_variable search81_0 = {
   15057    { nir_search_value_variable, 0 },
   15058    0, /* a */
   15059    false,
   15060    nir_type_invalid,
   15061    NULL,
   15062 };
   15063 
   15064 #include "compiler/nir/nir_search_helpers.h"
   15065 static const nir_search_variable search81_1 = {
   15066    { nir_search_value_variable, 0 },
   15067    0, /* a */
   15068    false,
   15069    nir_type_invalid,
   15070    NULL,
   15071 };
   15072 #include "compiler/nir/nir_search_helpers.h"
   15073 static const nir_search_expression search81 = {
   15074    { nir_search_value_expression, 0 },
   15075    false,
   15076    nir_op_imax,
   15077    { &search81_0.value, &search81_1.value },
   15078    NULL,
   15079 };
   15080 
   15081 #include "compiler/nir/nir_search_helpers.h"
   15082 static const nir_search_variable replace81 = {
   15083    { nir_search_value_variable, 0 },
   15084    0, /* a */
   15085    false,
   15086    nir_type_invalid,
   15087    NULL,
   15088 };
   15089 
   15090 static const struct transform nir_opt_algebraic_imax_xforms[] = {
   15091    { &search81, &replace81.value, 0 },
   15092 };
   15093 
   15094 #include "compiler/nir/nir_search_helpers.h"
   15095 static const nir_search_variable search86_0 = {
   15096    { nir_search_value_variable, 0 },
   15097    0, /* a */
   15098    false,
   15099    nir_type_invalid,
   15100    NULL,
   15101 };
   15102 #include "compiler/nir/nir_search_helpers.h"
   15103 static const nir_search_expression search86 = {
   15104    { nir_search_value_expression, 0 },
   15105    false,
   15106    nir_op_fsat,
   15107    { &search86_0.value },
   15108    NULL,
   15109 };
   15110 
   15111 #include "compiler/nir/nir_search_helpers.h"
   15112 static const nir_search_variable replace86_0_0 = {
   15113    { nir_search_value_variable, 0 },
   15114    0, /* a */
   15115    false,
   15116    nir_type_invalid,
   15117    NULL,
   15118 };
   15119 
   15120 #include "compiler/nir/nir_search_helpers.h"
   15121 static const nir_search_constant replace86_0_1 = {
   15122    { nir_search_value_constant, 0 },
   15123    nir_type_float, { 0x0 /* 0.0 */ },
   15124 };
   15125 #include "compiler/nir/nir_search_helpers.h"
   15126 static const nir_search_expression replace86_0 = {
   15127    { nir_search_value_expression, 0 },
   15128    false,
   15129    nir_op_fmax,
   15130    { &replace86_0_0.value, &replace86_0_1.value },
   15131    NULL,
   15132 };
   15133 
   15134 #include "compiler/nir/nir_search_helpers.h"
   15135 static const nir_search_constant replace86_1 = {
   15136    { nir_search_value_constant, 0 },
   15137    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   15138 };
   15139 #include "compiler/nir/nir_search_helpers.h"
   15140 static const nir_search_expression replace86 = {
   15141    { nir_search_value_expression, 0 },
   15142    false,
   15143    nir_op_fmin,
   15144    { &replace86_0.value, &replace86_1.value },
   15145    NULL,
   15146 };
   15147 
   15148 #include "compiler/nir/nir_search_helpers.h"
   15149 static const nir_search_variable search87_0_0 = {
   15150    { nir_search_value_variable, 0 },
   15151    0, /* a */
   15152    false,
   15153    nir_type_invalid,
   15154    NULL,
   15155 };
   15156 #include "compiler/nir/nir_search_helpers.h"
   15157 static const nir_search_expression search87_0 = {
   15158    { nir_search_value_expression, 0 },
   15159    false,
   15160    nir_op_fsat,
   15161    { &search87_0_0.value },
   15162    NULL,
   15163 };
   15164 #include "compiler/nir/nir_search_helpers.h"
   15165 static const nir_search_expression search87 = {
   15166    { nir_search_value_expression, 0 },
   15167    false,
   15168    nir_op_fsat,
   15169    { &search87_0.value },
   15170    NULL,
   15171 };
   15172 
   15173 #include "compiler/nir/nir_search_helpers.h"
   15174 static const nir_search_variable replace87_0 = {
   15175    { nir_search_value_variable, 0 },
   15176    0, /* a */
   15177    false,
   15178    nir_type_invalid,
   15179    NULL,
   15180 };
   15181 #include "compiler/nir/nir_search_helpers.h"
   15182 static const nir_search_expression replace87 = {
   15183    { nir_search_value_expression, 0 },
   15184    false,
   15185    nir_op_fsat,
   15186    { &replace87_0.value },
   15187    NULL,
   15188 };
   15189 
   15190 #include "compiler/nir/nir_search_helpers.h"
   15191 static const nir_search_variable search110_0_0_0 = {
   15192    { nir_search_value_variable, 0 },
   15193    0, /* a */
   15194    false,
   15195    nir_type_invalid,
   15196    NULL,
   15197 };
   15198 #include "compiler/nir/nir_search_helpers.h"
   15199 static const nir_search_expression search110_0_0 = {
   15200    { nir_search_value_expression, 0 },
   15201    false,
   15202    nir_op_b2f,
   15203    { &search110_0_0_0.value },
   15204    NULL,
   15205 };
   15206 
   15207 #include "compiler/nir/nir_search_helpers.h"
   15208 static const nir_search_variable search110_0_1_0 = {
   15209    { nir_search_value_variable, 0 },
   15210    1, /* b */
   15211    false,
   15212    nir_type_invalid,
   15213    NULL,
   15214 };
   15215 #include "compiler/nir/nir_search_helpers.h"
   15216 static const nir_search_expression search110_0_1 = {
   15217    { nir_search_value_expression, 0 },
   15218    false,
   15219    nir_op_b2f,
   15220    { &search110_0_1_0.value },
   15221    NULL,
   15222 };
   15223 #include "compiler/nir/nir_search_helpers.h"
   15224 static const nir_search_expression search110_0 = {
   15225    { nir_search_value_expression, 0 },
   15226    false,
   15227    nir_op_fadd,
   15228    { &search110_0_0.value, &search110_0_1.value },
   15229    NULL,
   15230 };
   15231 #include "compiler/nir/nir_search_helpers.h"
   15232 static const nir_search_expression search110 = {
   15233    { nir_search_value_expression, 0 },
   15234    false,
   15235    nir_op_fsat,
   15236    { &search110_0.value },
   15237    NULL,
   15238 };
   15239 
   15240 #include "compiler/nir/nir_search_helpers.h"
   15241 static const nir_search_variable replace110_0_0 = {
   15242    { nir_search_value_variable, 0 },
   15243    0, /* a */
   15244    false,
   15245    nir_type_invalid,
   15246    NULL,
   15247 };
   15248 
   15249 #include "compiler/nir/nir_search_helpers.h"
   15250 static const nir_search_variable replace110_0_1 = {
   15251    { nir_search_value_variable, 0 },
   15252    1, /* b */
   15253    false,
   15254    nir_type_invalid,
   15255    NULL,
   15256 };
   15257 #include "compiler/nir/nir_search_helpers.h"
   15258 static const nir_search_expression replace110_0 = {
   15259    { nir_search_value_expression, 0 },
   15260    false,
   15261    nir_op_ior,
   15262    { &replace110_0_0.value, &replace110_0_1.value },
   15263    NULL,
   15264 };
   15265 #include "compiler/nir/nir_search_helpers.h"
   15266 static const nir_search_expression replace110 = {
   15267    { nir_search_value_expression, 0 },
   15268    false,
   15269    nir_op_b2f,
   15270    { &replace110_0.value },
   15271    NULL,
   15272 };
   15273 
   15274 static const struct transform nir_opt_algebraic_fsat_xforms[] = {
   15275    { &search86, &replace86.value, 10 },
   15276    { &search87, &replace87.value, 0 },
   15277    { &search110, &replace110.value, 0 },
   15278 };
   15279 
   15280 #include "compiler/nir/nir_search_helpers.h"
   15281 static const nir_search_variable search224_0 = {
   15282    { nir_search_value_variable, 0 },
   15283    0, /* a */
   15284    false,
   15285    nir_type_invalid,
   15286    NULL,
   15287 };
   15288 
   15289 #include "compiler/nir/nir_search_helpers.h"
   15290 static const nir_search_variable search224_1 = {
   15291    { nir_search_value_variable, 0 },
   15292    1, /* b */
   15293    false,
   15294    nir_type_invalid,
   15295    NULL,
   15296 };
   15297 #include "compiler/nir/nir_search_helpers.h"
   15298 static const nir_search_expression search224 = {
   15299    { nir_search_value_expression, 0 },
   15300    false,
   15301    nir_op_extract_u16,
   15302    { &search224_0.value, &search224_1.value },
   15303    NULL,
   15304 };
   15305 
   15306 #include "compiler/nir/nir_search_helpers.h"
   15307 static const nir_search_variable replace224_0_0 = {
   15308    { nir_search_value_variable, 0 },
   15309    0, /* a */
   15310    false,
   15311    nir_type_invalid,
   15312    NULL,
   15313 };
   15314 
   15315 #include "compiler/nir/nir_search_helpers.h"
   15316 static const nir_search_variable replace224_0_1_0 = {
   15317    { nir_search_value_variable, 0 },
   15318    1, /* b */
   15319    false,
   15320    nir_type_invalid,
   15321    NULL,
   15322 };
   15323 
   15324 #include "compiler/nir/nir_search_helpers.h"
   15325 static const nir_search_constant replace224_0_1_1 = {
   15326    { nir_search_value_constant, 0 },
   15327    nir_type_int, { 0x10 /* 16 */ },
   15328 };
   15329 #include "compiler/nir/nir_search_helpers.h"
   15330 static const nir_search_expression replace224_0_1 = {
   15331    { nir_search_value_expression, 0 },
   15332    false,
   15333    nir_op_imul,
   15334    { &replace224_0_1_0.value, &replace224_0_1_1.value },
   15335    NULL,
   15336 };
   15337 #include "compiler/nir/nir_search_helpers.h"
   15338 static const nir_search_expression replace224_0 = {
   15339    { nir_search_value_expression, 0 },
   15340    false,
   15341    nir_op_ushr,
   15342    { &replace224_0_0.value, &replace224_0_1.value },
   15343    NULL,
   15344 };
   15345 
   15346 #include "compiler/nir/nir_search_helpers.h"
   15347 static const nir_search_constant replace224_1 = {
   15348    { nir_search_value_constant, 0 },
   15349    nir_type_int, { 0xffff /* 65535 */ },
   15350 };
   15351 #include "compiler/nir/nir_search_helpers.h"
   15352 static const nir_search_expression replace224 = {
   15353    { nir_search_value_expression, 0 },
   15354    false,
   15355    nir_op_iand,
   15356    { &replace224_0.value, &replace224_1.value },
   15357    NULL,
   15358 };
   15359 
   15360 static const struct transform nir_opt_algebraic_extract_u16_xforms[] = {
   15361    { &search224, &replace224.value, 28 },
   15362 };
   15363 
   15364 #include "compiler/nir/nir_search_helpers.h"
   15365 static const nir_search_constant search69_0 = {
   15366    { nir_search_value_constant, 0 },
   15367    nir_type_float, { 0x0 /* 0.0 */ },
   15368 };
   15369 
   15370 #include "compiler/nir/nir_search_helpers.h"
   15371 static const nir_search_variable search69_1_0 = {
   15372    { nir_search_value_variable, 0 },
   15373    0, /* a */
   15374    false,
   15375    nir_type_invalid,
   15376    NULL,
   15377 };
   15378 #include "compiler/nir/nir_search_helpers.h"
   15379 static const nir_search_expression search69_1 = {
   15380    { nir_search_value_expression, 0 },
   15381    false,
   15382    nir_op_b2f,
   15383    { &search69_1_0.value },
   15384    NULL,
   15385 };
   15386 #include "compiler/nir/nir_search_helpers.h"
   15387 static const nir_search_expression search69 = {
   15388    { nir_search_value_expression, 0 },
   15389    false,
   15390    nir_op_fge,
   15391    { &search69_0.value, &search69_1.value },
   15392    NULL,
   15393 };
   15394 
   15395 #include "compiler/nir/nir_search_helpers.h"
   15396 static const nir_search_variable replace69_0 = {
   15397    { nir_search_value_variable, 0 },
   15398    0, /* a */
   15399    false,
   15400    nir_type_invalid,
   15401    NULL,
   15402 };
   15403 #include "compiler/nir/nir_search_helpers.h"
   15404 static const nir_search_expression replace69 = {
   15405    { nir_search_value_expression, 0 },
   15406    false,
   15407    nir_op_inot,
   15408    { &replace69_0.value },
   15409    NULL,
   15410 };
   15411 
   15412 #include "compiler/nir/nir_search_helpers.h"
   15413 static const nir_search_variable search70_0_0_0 = {
   15414    { nir_search_value_variable, 0 },
   15415    0, /* a */
   15416    false,
   15417    nir_type_invalid,
   15418    NULL,
   15419 };
   15420 #include "compiler/nir/nir_search_helpers.h"
   15421 static const nir_search_expression search70_0_0 = {
   15422    { nir_search_value_expression, 0 },
   15423    false,
   15424    nir_op_b2f,
   15425    { &search70_0_0_0.value },
   15426    NULL,
   15427 };
   15428 #include "compiler/nir/nir_search_helpers.h"
   15429 static const nir_search_expression search70_0 = {
   15430    { nir_search_value_expression, 0 },
   15431    false,
   15432    nir_op_fneg,
   15433    { &search70_0_0.value },
   15434    NULL,
   15435 };
   15436 
   15437 #include "compiler/nir/nir_search_helpers.h"
   15438 static const nir_search_constant search70_1 = {
   15439    { nir_search_value_constant, 0 },
   15440    nir_type_float, { 0x0 /* 0.0 */ },
   15441 };
   15442 #include "compiler/nir/nir_search_helpers.h"
   15443 static const nir_search_expression search70 = {
   15444    { nir_search_value_expression, 0 },
   15445    false,
   15446    nir_op_fge,
   15447    { &search70_0.value, &search70_1.value },
   15448    NULL,
   15449 };
   15450 
   15451 #include "compiler/nir/nir_search_helpers.h"
   15452 static const nir_search_variable replace70_0 = {
   15453    { nir_search_value_variable, 0 },
   15454    0, /* a */
   15455    false,
   15456    nir_type_invalid,
   15457    NULL,
   15458 };
   15459 #include "compiler/nir/nir_search_helpers.h"
   15460 static const nir_search_expression replace70 = {
   15461    { nir_search_value_expression, 0 },
   15462    false,
   15463    nir_op_inot,
   15464    { &replace70_0.value },
   15465    NULL,
   15466 };
   15467 
   15468 #include "compiler/nir/nir_search_helpers.h"
   15469 static const nir_search_variable search72_0_0_0 = {
   15470    { nir_search_value_variable, 0 },
   15471    0, /* a */
   15472    false,
   15473    nir_type_invalid,
   15474    NULL,
   15475 };
   15476 #include "compiler/nir/nir_search_helpers.h"
   15477 static const nir_search_expression search72_0_0 = {
   15478    { nir_search_value_expression, 0 },
   15479    false,
   15480    nir_op_fabs,
   15481    { &search72_0_0_0.value },
   15482    NULL,
   15483 };
   15484 #include "compiler/nir/nir_search_helpers.h"
   15485 static const nir_search_expression search72_0 = {
   15486    { nir_search_value_expression, 0 },
   15487    false,
   15488    nir_op_fneg,
   15489    { &search72_0_0.value },
   15490    NULL,
   15491 };
   15492 
   15493 #include "compiler/nir/nir_search_helpers.h"
   15494 static const nir_search_constant search72_1 = {
   15495    { nir_search_value_constant, 0 },
   15496    nir_type_float, { 0x0 /* 0.0 */ },
   15497 };
   15498 #include "compiler/nir/nir_search_helpers.h"
   15499 static const nir_search_expression search72 = {
   15500    { nir_search_value_expression, 0 },
   15501    false,
   15502    nir_op_fge,
   15503    { &search72_0.value, &search72_1.value },
   15504    NULL,
   15505 };
   15506 
   15507 #include "compiler/nir/nir_search_helpers.h"
   15508 static const nir_search_variable replace72_0 = {
   15509    { nir_search_value_variable, 0 },
   15510    0, /* a */
   15511    false,
   15512    nir_type_invalid,
   15513    NULL,
   15514 };
   15515 
   15516 #include "compiler/nir/nir_search_helpers.h"
   15517 static const nir_search_constant replace72_1 = {
   15518    { nir_search_value_constant, 0 },
   15519    nir_type_float, { 0x0 /* 0.0 */ },
   15520 };
   15521 #include "compiler/nir/nir_search_helpers.h"
   15522 static const nir_search_expression replace72 = {
   15523    { nir_search_value_expression, 0 },
   15524    false,
   15525    nir_op_feq,
   15526    { &replace72_0.value, &replace72_1.value },
   15527    NULL,
   15528 };
   15529 
   15530 #include "compiler/nir/nir_search_helpers.h"
   15531 static const nir_search_variable search244_0_0 = {
   15532    { nir_search_value_variable, 0 },
   15533    0, /* a */
   15534    false,
   15535    nir_type_invalid,
   15536    NULL,
   15537 };
   15538 
   15539 #include "compiler/nir/nir_search_helpers.h"
   15540 static const nir_search_variable search244_0_1 = {
   15541    { nir_search_value_variable, 0 },
   15542    1, /* b */
   15543    true,
   15544    nir_type_invalid,
   15545    NULL,
   15546 };
   15547 
   15548 #include "compiler/nir/nir_search_helpers.h"
   15549 static const nir_search_variable search244_0_2 = {
   15550    { nir_search_value_variable, 0 },
   15551    2, /* c */
   15552    true,
   15553    nir_type_invalid,
   15554    NULL,
   15555 };
   15556 #include "compiler/nir/nir_search_helpers.h"
   15557 static const nir_search_expression search244_0 = {
   15558    { nir_search_value_expression, 0 },
   15559    false,
   15560    nir_op_bcsel,
   15561    { &search244_0_0.value, &search244_0_1.value, &search244_0_2.value },
   15562    NULL,
   15563 };
   15564 
   15565 #include "compiler/nir/nir_search_helpers.h"
   15566 static const nir_search_variable search244_1 = {
   15567    { nir_search_value_variable, 0 },
   15568    3, /* d */
   15569    true,
   15570    nir_type_invalid,
   15571    NULL,
   15572 };
   15573 #include "compiler/nir/nir_search_helpers.h"
   15574 static const nir_search_expression search244 = {
   15575    { nir_search_value_expression, 0 },
   15576    false,
   15577    nir_op_fge,
   15578    { &search244_0.value, &search244_1.value },
   15579    NULL,
   15580 };
   15581 
   15582 #include "compiler/nir/nir_search_helpers.h"
   15583 static const nir_search_variable replace244_0 = {
   15584    { nir_search_value_variable, 0 },
   15585    0, /* a */
   15586    false,
   15587    nir_type_invalid,
   15588    NULL,
   15589 };
   15590 
   15591 #include "compiler/nir/nir_search_helpers.h"
   15592 static const nir_search_variable replace244_1_0 = {
   15593    { nir_search_value_variable, 0 },
   15594    1, /* b */
   15595    false,
   15596    nir_type_invalid,
   15597    NULL,
   15598 };
   15599 
   15600 #include "compiler/nir/nir_search_helpers.h"
   15601 static const nir_search_variable replace244_1_1 = {
   15602    { nir_search_value_variable, 0 },
   15603    3, /* d */
   15604    false,
   15605    nir_type_invalid,
   15606    NULL,
   15607 };
   15608 #include "compiler/nir/nir_search_helpers.h"
   15609 static const nir_search_expression replace244_1 = {
   15610    { nir_search_value_expression, 0 },
   15611    false,
   15612    nir_op_fge,
   15613    { &replace244_1_0.value, &replace244_1_1.value },
   15614    NULL,
   15615 };
   15616 
   15617 #include "compiler/nir/nir_search_helpers.h"
   15618 static const nir_search_variable replace244_2_0 = {
   15619    { nir_search_value_variable, 0 },
   15620    2, /* c */
   15621    false,
   15622    nir_type_invalid,
   15623    NULL,
   15624 };
   15625 
   15626 #include "compiler/nir/nir_search_helpers.h"
   15627 static const nir_search_variable replace244_2_1 = {
   15628    { nir_search_value_variable, 0 },
   15629    3, /* d */
   15630    false,
   15631    nir_type_invalid,
   15632    NULL,
   15633 };
   15634 #include "compiler/nir/nir_search_helpers.h"
   15635 static const nir_search_expression replace244_2 = {
   15636    { nir_search_value_expression, 0 },
   15637    false,
   15638    nir_op_fge,
   15639    { &replace244_2_0.value, &replace244_2_1.value },
   15640    NULL,
   15641 };
   15642 #include "compiler/nir/nir_search_helpers.h"
   15643 static const nir_search_expression replace244 = {
   15644    { nir_search_value_expression, 0 },
   15645    false,
   15646    nir_op_bcsel,
   15647    { &replace244_0.value, &replace244_1.value, &replace244_2.value },
   15648    NULL,
   15649 };
   15650 
   15651 #include "compiler/nir/nir_search_helpers.h"
   15652 static const nir_search_variable search245_0 = {
   15653    { nir_search_value_variable, 0 },
   15654    0, /* d */
   15655    true,
   15656    nir_type_invalid,
   15657    NULL,
   15658 };
   15659 
   15660 #include "compiler/nir/nir_search_helpers.h"
   15661 static const nir_search_variable search245_1_0 = {
   15662    { nir_search_value_variable, 0 },
   15663    1, /* a */
   15664    false,
   15665    nir_type_invalid,
   15666    NULL,
   15667 };
   15668 
   15669 #include "compiler/nir/nir_search_helpers.h"
   15670 static const nir_search_variable search245_1_1 = {
   15671    { nir_search_value_variable, 0 },
   15672    2, /* b */
   15673    true,
   15674    nir_type_invalid,
   15675    NULL,
   15676 };
   15677 
   15678 #include "compiler/nir/nir_search_helpers.h"
   15679 static const nir_search_variable search245_1_2 = {
   15680    { nir_search_value_variable, 0 },
   15681    3, /* c */
   15682    true,
   15683    nir_type_invalid,
   15684    NULL,
   15685 };
   15686 #include "compiler/nir/nir_search_helpers.h"
   15687 static const nir_search_expression search245_1 = {
   15688    { nir_search_value_expression, 0 },
   15689    false,
   15690    nir_op_bcsel,
   15691    { &search245_1_0.value, &search245_1_1.value, &search245_1_2.value },
   15692    NULL,
   15693 };
   15694 #include "compiler/nir/nir_search_helpers.h"
   15695 static const nir_search_expression search245 = {
   15696    { nir_search_value_expression, 0 },
   15697    false,
   15698    nir_op_fge,
   15699    { &search245_0.value, &search245_1.value },
   15700    NULL,
   15701 };
   15702 
   15703 #include "compiler/nir/nir_search_helpers.h"
   15704 static const nir_search_variable replace245_0 = {
   15705    { nir_search_value_variable, 0 },
   15706    1, /* a */
   15707    false,
   15708    nir_type_invalid,
   15709    NULL,
   15710 };
   15711 
   15712 #include "compiler/nir/nir_search_helpers.h"
   15713 static const nir_search_variable replace245_1_0 = {
   15714    { nir_search_value_variable, 0 },
   15715    0, /* d */
   15716    false,
   15717    nir_type_invalid,
   15718    NULL,
   15719 };
   15720 
   15721 #include "compiler/nir/nir_search_helpers.h"
   15722 static const nir_search_variable replace245_1_1 = {
   15723    { nir_search_value_variable, 0 },
   15724    2, /* b */
   15725    false,
   15726    nir_type_invalid,
   15727    NULL,
   15728 };
   15729 #include "compiler/nir/nir_search_helpers.h"
   15730 static const nir_search_expression replace245_1 = {
   15731    { nir_search_value_expression, 0 },
   15732    false,
   15733    nir_op_fge,
   15734    { &replace245_1_0.value, &replace245_1_1.value },
   15735    NULL,
   15736 };
   15737 
   15738 #include "compiler/nir/nir_search_helpers.h"
   15739 static const nir_search_variable replace245_2_0 = {
   15740    { nir_search_value_variable, 0 },
   15741    0, /* d */
   15742    false,
   15743    nir_type_invalid,
   15744    NULL,
   15745 };
   15746 
   15747 #include "compiler/nir/nir_search_helpers.h"
   15748 static const nir_search_variable replace245_2_1 = {
   15749    { nir_search_value_variable, 0 },
   15750    3, /* c */
   15751    false,
   15752    nir_type_invalid,
   15753    NULL,
   15754 };
   15755 #include "compiler/nir/nir_search_helpers.h"
   15756 static const nir_search_expression replace245_2 = {
   15757    { nir_search_value_expression, 0 },
   15758    false,
   15759    nir_op_fge,
   15760    { &replace245_2_0.value, &replace245_2_1.value },
   15761    NULL,
   15762 };
   15763 #include "compiler/nir/nir_search_helpers.h"
   15764 static const nir_search_expression replace245 = {
   15765    { nir_search_value_expression, 0 },
   15766    false,
   15767    nir_op_bcsel,
   15768    { &replace245_0.value, &replace245_1.value, &replace245_2.value },
   15769    NULL,
   15770 };
   15771 
   15772 static const struct transform nir_opt_algebraic_fge_xforms[] = {
   15773    { &search69, &replace69.value, 0 },
   15774    { &search70, &replace70.value, 0 },
   15775    { &search72, &replace72.value, 0 },
   15776    { &search244, &replace244.value, 0 },
   15777    { &search245, &replace245.value, 0 },
   15778 };
   15779 
   15780 #include "compiler/nir/nir_search_helpers.h"
   15781 static const nir_search_variable search154_0_0 = {
   15782    { nir_search_value_variable, 0 },
   15783    0, /* a */
   15784    false,
   15785    nir_type_invalid,
   15786    NULL,
   15787 };
   15788 #include "compiler/nir/nir_search_helpers.h"
   15789 static const nir_search_expression search154_0 = {
   15790    { nir_search_value_expression, 0 },
   15791    false,
   15792    nir_op_fexp2,
   15793    { &search154_0_0.value },
   15794    NULL,
   15795 };
   15796 #include "compiler/nir/nir_search_helpers.h"
   15797 static const nir_search_expression search154 = {
   15798    { nir_search_value_expression, 0 },
   15799    true,
   15800    nir_op_frcp,
   15801    { &search154_0.value },
   15802    NULL,
   15803 };
   15804 
   15805 #include "compiler/nir/nir_search_helpers.h"
   15806 static const nir_search_variable replace154_0_0 = {
   15807    { nir_search_value_variable, 0 },
   15808    0, /* a */
   15809    false,
   15810    nir_type_invalid,
   15811    NULL,
   15812 };
   15813 #include "compiler/nir/nir_search_helpers.h"
   15814 static const nir_search_expression replace154_0 = {
   15815    { nir_search_value_expression, 0 },
   15816    false,
   15817    nir_op_fneg,
   15818    { &replace154_0_0.value },
   15819    NULL,
   15820 };
   15821 #include "compiler/nir/nir_search_helpers.h"
   15822 static const nir_search_expression replace154 = {
   15823    { nir_search_value_expression, 0 },
   15824    false,
   15825    nir_op_fexp2,
   15826    { &replace154_0.value },
   15827    NULL,
   15828 };
   15829 
   15830 #include "compiler/nir/nir_search_helpers.h"
   15831 static const nir_search_variable search163_0_0 = {
   15832    { nir_search_value_variable, 0 },
   15833    0, /* a */
   15834    false,
   15835    nir_type_invalid,
   15836    NULL,
   15837 };
   15838 #include "compiler/nir/nir_search_helpers.h"
   15839 static const nir_search_expression search163_0 = {
   15840    { nir_search_value_expression, 0 },
   15841    false,
   15842    nir_op_frcp,
   15843    { &search163_0_0.value },
   15844    NULL,
   15845 };
   15846 #include "compiler/nir/nir_search_helpers.h"
   15847 static const nir_search_expression search163 = {
   15848    { nir_search_value_expression, 0 },
   15849    true,
   15850    nir_op_frcp,
   15851    { &search163_0.value },
   15852    NULL,
   15853 };
   15854 
   15855 #include "compiler/nir/nir_search_helpers.h"
   15856 static const nir_search_variable replace163 = {
   15857    { nir_search_value_variable, 0 },
   15858    0, /* a */
   15859    false,
   15860    nir_type_invalid,
   15861    NULL,
   15862 };
   15863 
   15864 #include "compiler/nir/nir_search_helpers.h"
   15865 static const nir_search_variable search164_0_0 = {
   15866    { nir_search_value_variable, 0 },
   15867    0, /* a */
   15868    false,
   15869    nir_type_invalid,
   15870    NULL,
   15871 };
   15872 #include "compiler/nir/nir_search_helpers.h"
   15873 static const nir_search_expression search164_0 = {
   15874    { nir_search_value_expression, 0 },
   15875    false,
   15876    nir_op_fsqrt,
   15877    { &search164_0_0.value },
   15878    NULL,
   15879 };
   15880 #include "compiler/nir/nir_search_helpers.h"
   15881 static const nir_search_expression search164 = {
   15882    { nir_search_value_expression, 0 },
   15883    true,
   15884    nir_op_frcp,
   15885    { &search164_0.value },
   15886    NULL,
   15887 };
   15888 
   15889 #include "compiler/nir/nir_search_helpers.h"
   15890 static const nir_search_variable replace164_0 = {
   15891    { nir_search_value_variable, 0 },
   15892    0, /* a */
   15893    false,
   15894    nir_type_invalid,
   15895    NULL,
   15896 };
   15897 #include "compiler/nir/nir_search_helpers.h"
   15898 static const nir_search_expression replace164 = {
   15899    { nir_search_value_expression, 0 },
   15900    false,
   15901    nir_op_frsq,
   15902    { &replace164_0.value },
   15903    NULL,
   15904 };
   15905 
   15906 #include "compiler/nir/nir_search_helpers.h"
   15907 static const nir_search_variable search166_0_0 = {
   15908    { nir_search_value_variable, 0 },
   15909    0, /* a */
   15910    false,
   15911    nir_type_invalid,
   15912    NULL,
   15913 };
   15914 #include "compiler/nir/nir_search_helpers.h"
   15915 static const nir_search_expression search166_0 = {
   15916    { nir_search_value_expression, 0 },
   15917    false,
   15918    nir_op_frsq,
   15919    { &search166_0_0.value },
   15920    NULL,
   15921 };
   15922 #include "compiler/nir/nir_search_helpers.h"
   15923 static const nir_search_expression search166 = {
   15924    { nir_search_value_expression, 0 },
   15925    true,
   15926    nir_op_frcp,
   15927    { &search166_0.value },
   15928    NULL,
   15929 };
   15930 
   15931 #include "compiler/nir/nir_search_helpers.h"
   15932 static const nir_search_variable replace166_0 = {
   15933    { nir_search_value_variable, 0 },
   15934    0, /* a */
   15935    false,
   15936    nir_type_invalid,
   15937    NULL,
   15938 };
   15939 #include "compiler/nir/nir_search_helpers.h"
   15940 static const nir_search_expression replace166 = {
   15941    { nir_search_value_expression, 0 },
   15942    false,
   15943    nir_op_fsqrt,
   15944    { &replace166_0.value },
   15945    NULL,
   15946 };
   15947 
   15948 static const struct transform nir_opt_algebraic_frcp_xforms[] = {
   15949    { &search154, &replace154.value, 0 },
   15950    { &search163, &replace163.value, 0 },
   15951    { &search164, &replace164.value, 0 },
   15952    { &search166, &replace166.value, 16 },
   15953 };
   15954 
   15955 #include "compiler/nir/nir_search_helpers.h"
   15956 static const nir_search_variable search128_0 = {
   15957    { nir_search_value_variable, 0 },
   15958    0, /* a */
   15959    false,
   15960    nir_type_invalid,
   15961    NULL,
   15962 };
   15963 
   15964 #include "compiler/nir/nir_search_helpers.h"
   15965 static const nir_search_variable search128_1 = {
   15966    { nir_search_value_variable, 0 },
   15967    0, /* a */
   15968    false,
   15969    nir_type_invalid,
   15970    NULL,
   15971 };
   15972 #include "compiler/nir/nir_search_helpers.h"
   15973 static const nir_search_expression search128 = {
   15974    { nir_search_value_expression, 0 },
   15975    false,
   15976    nir_op_fxor,
   15977    { &search128_0.value, &search128_1.value },
   15978    NULL,
   15979 };
   15980 
   15981 #include "compiler/nir/nir_search_helpers.h"
   15982 static const nir_search_constant replace128 = {
   15983    { nir_search_value_constant, 0 },
   15984    nir_type_float, { 0x0 /* 0.0 */ },
   15985 };
   15986 
   15987 static const struct transform nir_opt_algebraic_fxor_xforms[] = {
   15988    { &search128, &replace128.value, 0 },
   15989 };
   15990 
   15991 #include "compiler/nir/nir_search_helpers.h"
   15992 static const nir_search_constant search138_0 = {
   15993    { nir_search_value_constant, 0 },
   15994    nir_type_int, { 0x0 /* 0 */ },
   15995 };
   15996 
   15997 #include "compiler/nir/nir_search_helpers.h"
   15998 static const nir_search_variable search138_1 = {
   15999    { nir_search_value_variable, 0 },
   16000    0, /* a */
   16001    false,
   16002    nir_type_invalid,
   16003    NULL,
   16004 };
   16005 #include "compiler/nir/nir_search_helpers.h"
   16006 static const nir_search_expression search138 = {
   16007    { nir_search_value_expression, 0 },
   16008    false,
   16009    nir_op_ushr,
   16010    { &search138_0.value, &search138_1.value },
   16011    NULL,
   16012 };
   16013 
   16014 #include "compiler/nir/nir_search_helpers.h"
   16015 static const nir_search_constant replace138 = {
   16016    { nir_search_value_constant, 0 },
   16017    nir_type_int, { 0x0 /* 0 */ },
   16018 };
   16019 
   16020 #include "compiler/nir/nir_search_helpers.h"
   16021 static const nir_search_variable search139_0 = {
   16022    { nir_search_value_variable, 0 },
   16023    0, /* a */
   16024    false,
   16025    nir_type_invalid,
   16026    NULL,
   16027 };
   16028 
   16029 #include "compiler/nir/nir_search_helpers.h"
   16030 static const nir_search_constant search139_1 = {
   16031    { nir_search_value_constant, 0 },
   16032    nir_type_int, { 0x0 /* 0 */ },
   16033 };
   16034 #include "compiler/nir/nir_search_helpers.h"
   16035 static const nir_search_expression search139 = {
   16036    { nir_search_value_expression, 0 },
   16037    false,
   16038    nir_op_ushr,
   16039    { &search139_0.value, &search139_1.value },
   16040    NULL,
   16041 };
   16042 
   16043 #include "compiler/nir/nir_search_helpers.h"
   16044 static const nir_search_variable replace139 = {
   16045    { nir_search_value_variable, 0 },
   16046    0, /* a */
   16047    false,
   16048    nir_type_invalid,
   16049    NULL,
   16050 };
   16051 
   16052 #include "compiler/nir/nir_search_helpers.h"
   16053 static const nir_search_variable search189_0 = {
   16054    { nir_search_value_variable, 0 },
   16055    0, /* a */
   16056    false,
   16057    nir_type_invalid,
   16058    NULL,
   16059 };
   16060 
   16061 #include "compiler/nir/nir_search_helpers.h"
   16062 static const nir_search_constant search189_1 = {
   16063    { nir_search_value_constant, 0 },
   16064    nir_type_int, { 0x18 /* 24 */ },
   16065 };
   16066 #include "compiler/nir/nir_search_helpers.h"
   16067 static const nir_search_expression search189 = {
   16068    { nir_search_value_expression, 0 },
   16069    false,
   16070    nir_op_ushr,
   16071    { &search189_0.value, &search189_1.value },
   16072    NULL,
   16073 };
   16074 
   16075 #include "compiler/nir/nir_search_helpers.h"
   16076 static const nir_search_variable replace189_0 = {
   16077    { nir_search_value_variable, 0 },
   16078    0, /* a */
   16079    false,
   16080    nir_type_invalid,
   16081    NULL,
   16082 };
   16083 
   16084 #include "compiler/nir/nir_search_helpers.h"
   16085 static const nir_search_constant replace189_1 = {
   16086    { nir_search_value_constant, 0 },
   16087    nir_type_int, { 0x3 /* 3 */ },
   16088 };
   16089 #include "compiler/nir/nir_search_helpers.h"
   16090 static const nir_search_expression replace189 = {
   16091    { nir_search_value_expression, 0 },
   16092    false,
   16093    nir_op_extract_u8,
   16094    { &replace189_0.value, &replace189_1.value },
   16095    NULL,
   16096 };
   16097 
   16098 #include "compiler/nir/nir_search_helpers.h"
   16099 static const nir_search_variable search193_0 = {
   16100    { nir_search_value_variable, 0 },
   16101    0, /* a */
   16102    false,
   16103    nir_type_invalid,
   16104    NULL,
   16105 };
   16106 
   16107 #include "compiler/nir/nir_search_helpers.h"
   16108 static const nir_search_constant search193_1 = {
   16109    { nir_search_value_constant, 0 },
   16110    nir_type_int, { 0x10 /* 16 */ },
   16111 };
   16112 #include "compiler/nir/nir_search_helpers.h"
   16113 static const nir_search_expression search193 = {
   16114    { nir_search_value_expression, 0 },
   16115    false,
   16116    nir_op_ushr,
   16117    { &search193_0.value, &search193_1.value },
   16118    NULL,
   16119 };
   16120 
   16121 #include "compiler/nir/nir_search_helpers.h"
   16122 static const nir_search_variable replace193_0 = {
   16123    { nir_search_value_variable, 0 },
   16124    0, /* a */
   16125    false,
   16126    nir_type_invalid,
   16127    NULL,
   16128 };
   16129 
   16130 #include "compiler/nir/nir_search_helpers.h"
   16131 static const nir_search_constant replace193_1 = {
   16132    { nir_search_value_constant, 0 },
   16133    nir_type_int, { 0x1 /* 1 */ },
   16134 };
   16135 #include "compiler/nir/nir_search_helpers.h"
   16136 static const nir_search_expression replace193 = {
   16137    { nir_search_value_expression, 0 },
   16138    false,
   16139    nir_op_extract_u16,
   16140    { &replace193_0.value, &replace193_1.value },
   16141    NULL,
   16142 };
   16143 
   16144 static const struct transform nir_opt_algebraic_ushr_xforms[] = {
   16145    { &search138, &replace138.value, 0 },
   16146    { &search139, &replace139.value, 0 },
   16147    { &search189, &replace189.value, 17 },
   16148    { &search193, &replace193.value, 18 },
   16149 };
   16150 
   16151 #include "compiler/nir/nir_search_helpers.h"
   16152 static const nir_search_variable search142_0_0 = {
   16153    { nir_search_value_variable, 0 },
   16154    0, /* a */
   16155    false,
   16156    nir_type_invalid,
   16157    NULL,
   16158 };
   16159 #include "compiler/nir/nir_search_helpers.h"
   16160 static const nir_search_expression search142_0 = {
   16161    { nir_search_value_expression, 0 },
   16162    false,
   16163    nir_op_flog2,
   16164    { &search142_0_0.value },
   16165    NULL,
   16166 };
   16167 #include "compiler/nir/nir_search_helpers.h"
   16168 static const nir_search_expression search142 = {
   16169    { nir_search_value_expression, 0 },
   16170    true,
   16171    nir_op_fexp2,
   16172    { &search142_0.value },
   16173    NULL,
   16174 };
   16175 
   16176 #include "compiler/nir/nir_search_helpers.h"
   16177 static const nir_search_variable replace142 = {
   16178    { nir_search_value_variable, 0 },
   16179    0, /* a */
   16180    false,
   16181    nir_type_invalid,
   16182    NULL,
   16183 };
   16184 
   16185 #include "compiler/nir/nir_search_helpers.h"
   16186 static const nir_search_variable search145_0_0_0 = {
   16187    { nir_search_value_variable, 0 },
   16188    0, /* a */
   16189    false,
   16190    nir_type_invalid,
   16191    NULL,
   16192 };
   16193 #include "compiler/nir/nir_search_helpers.h"
   16194 static const nir_search_expression search145_0_0 = {
   16195    { nir_search_value_expression, 0 },
   16196    false,
   16197    nir_op_flog2,
   16198    { &search145_0_0_0.value },
   16199    NULL,
   16200 };
   16201 
   16202 #include "compiler/nir/nir_search_helpers.h"
   16203 static const nir_search_variable search145_0_1 = {
   16204    { nir_search_value_variable, 0 },
   16205    1, /* b */
   16206    false,
   16207    nir_type_invalid,
   16208    NULL,
   16209 };
   16210 #include "compiler/nir/nir_search_helpers.h"
   16211 static const nir_search_expression search145_0 = {
   16212    { nir_search_value_expression, 0 },
   16213    false,
   16214    nir_op_fmul,
   16215    { &search145_0_0.value, &search145_0_1.value },
   16216    NULL,
   16217 };
   16218 #include "compiler/nir/nir_search_helpers.h"
   16219 static const nir_search_expression search145 = {
   16220    { nir_search_value_expression, 0 },
   16221    true,
   16222    nir_op_fexp2,
   16223    { &search145_0.value },
   16224    NULL,
   16225 };
   16226 
   16227 #include "compiler/nir/nir_search_helpers.h"
   16228 static const nir_search_variable replace145_0 = {
   16229    { nir_search_value_variable, 0 },
   16230    0, /* a */
   16231    false,
   16232    nir_type_invalid,
   16233    NULL,
   16234 };
   16235 
   16236 #include "compiler/nir/nir_search_helpers.h"
   16237 static const nir_search_variable replace145_1 = {
   16238    { nir_search_value_variable, 0 },
   16239    1, /* b */
   16240    false,
   16241    nir_type_invalid,
   16242    NULL,
   16243 };
   16244 #include "compiler/nir/nir_search_helpers.h"
   16245 static const nir_search_expression replace145 = {
   16246    { nir_search_value_expression, 0 },
   16247    false,
   16248    nir_op_fpow,
   16249    { &replace145_0.value, &replace145_1.value },
   16250    NULL,
   16251 };
   16252 
   16253 #include "compiler/nir/nir_search_helpers.h"
   16254 static const nir_search_variable search146_0_0_0_0 = {
   16255    { nir_search_value_variable, 0 },
   16256    0, /* a */
   16257    false,
   16258    nir_type_invalid,
   16259    NULL,
   16260 };
   16261 #include "compiler/nir/nir_search_helpers.h"
   16262 static const nir_search_expression search146_0_0_0 = {
   16263    { nir_search_value_expression, 0 },
   16264    false,
   16265    nir_op_flog2,
   16266    { &search146_0_0_0_0.value },
   16267    NULL,
   16268 };
   16269 
   16270 #include "compiler/nir/nir_search_helpers.h"
   16271 static const nir_search_variable search146_0_0_1 = {
   16272    { nir_search_value_variable, 0 },
   16273    1, /* b */
   16274    false,
   16275    nir_type_invalid,
   16276    NULL,
   16277 };
   16278 #include "compiler/nir/nir_search_helpers.h"
   16279 static const nir_search_expression search146_0_0 = {
   16280    { nir_search_value_expression, 0 },
   16281    false,
   16282    nir_op_fmul,
   16283    { &search146_0_0_0.value, &search146_0_0_1.value },
   16284    NULL,
   16285 };
   16286 
   16287 #include "compiler/nir/nir_search_helpers.h"
   16288 static const nir_search_variable search146_0_1_0_0 = {
   16289    { nir_search_value_variable, 0 },
   16290    2, /* c */
   16291    false,
   16292    nir_type_invalid,
   16293    NULL,
   16294 };
   16295 #include "compiler/nir/nir_search_helpers.h"
   16296 static const nir_search_expression search146_0_1_0 = {
   16297    { nir_search_value_expression, 0 },
   16298    false,
   16299    nir_op_flog2,
   16300    { &search146_0_1_0_0.value },
   16301    NULL,
   16302 };
   16303 
   16304 #include "compiler/nir/nir_search_helpers.h"
   16305 static const nir_search_variable search146_0_1_1 = {
   16306    { nir_search_value_variable, 0 },
   16307    3, /* d */
   16308    false,
   16309    nir_type_invalid,
   16310    NULL,
   16311 };
   16312 #include "compiler/nir/nir_search_helpers.h"
   16313 static const nir_search_expression search146_0_1 = {
   16314    { nir_search_value_expression, 0 },
   16315    false,
   16316    nir_op_fmul,
   16317    { &search146_0_1_0.value, &search146_0_1_1.value },
   16318    NULL,
   16319 };
   16320 #include "compiler/nir/nir_search_helpers.h"
   16321 static const nir_search_expression search146_0 = {
   16322    { nir_search_value_expression, 0 },
   16323    false,
   16324    nir_op_fadd,
   16325    { &search146_0_0.value, &search146_0_1.value },
   16326    NULL,
   16327 };
   16328 #include "compiler/nir/nir_search_helpers.h"
   16329 static const nir_search_expression search146 = {
   16330    { nir_search_value_expression, 0 },
   16331    true,
   16332    nir_op_fexp2,
   16333    { &search146_0.value },
   16334    NULL,
   16335 };
   16336 
   16337 #include "compiler/nir/nir_search_helpers.h"
   16338 static const nir_search_variable replace146_0_0 = {
   16339    { nir_search_value_variable, 0 },
   16340    0, /* a */
   16341    false,
   16342    nir_type_invalid,
   16343    NULL,
   16344 };
   16345 
   16346 #include "compiler/nir/nir_search_helpers.h"
   16347 static const nir_search_variable replace146_0_1 = {
   16348    { nir_search_value_variable, 0 },
   16349    1, /* b */
   16350    false,
   16351    nir_type_invalid,
   16352    NULL,
   16353 };
   16354 #include "compiler/nir/nir_search_helpers.h"
   16355 static const nir_search_expression replace146_0 = {
   16356    { nir_search_value_expression, 0 },
   16357    false,
   16358    nir_op_fpow,
   16359    { &replace146_0_0.value, &replace146_0_1.value },
   16360    NULL,
   16361 };
   16362 
   16363 #include "compiler/nir/nir_search_helpers.h"
   16364 static const nir_search_variable replace146_1_0 = {
   16365    { nir_search_value_variable, 0 },
   16366    2, /* c */
   16367    false,
   16368    nir_type_invalid,
   16369    NULL,
   16370 };
   16371 
   16372 #include "compiler/nir/nir_search_helpers.h"
   16373 static const nir_search_variable replace146_1_1 = {
   16374    { nir_search_value_variable, 0 },
   16375    3, /* d */
   16376    false,
   16377    nir_type_invalid,
   16378    NULL,
   16379 };
   16380 #include "compiler/nir/nir_search_helpers.h"
   16381 static const nir_search_expression replace146_1 = {
   16382    { nir_search_value_expression, 0 },
   16383    false,
   16384    nir_op_fpow,
   16385    { &replace146_1_0.value, &replace146_1_1.value },
   16386    NULL,
   16387 };
   16388 #include "compiler/nir/nir_search_helpers.h"
   16389 static const nir_search_expression replace146 = {
   16390    { nir_search_value_expression, 0 },
   16391    true,
   16392    nir_op_fmul,
   16393    { &replace146_0.value, &replace146_1.value },
   16394    NULL,
   16395 };
   16396 
   16397 static const struct transform nir_opt_algebraic_fexp2_xforms[] = {
   16398    { &search142, &replace142.value, 0 },
   16399    { &search145, &replace145.value, 13 },
   16400    { &search146, &replace146.value, 13 },
   16401 };
   16402 
   16403 #include "compiler/nir/nir_search_helpers.h"
   16404 static const nir_search_constant search136_0 = {
   16405    { nir_search_value_constant, 0 },
   16406    nir_type_int, { 0x0 /* 0 */ },
   16407 };
   16408 
   16409 #include "compiler/nir/nir_search_helpers.h"
   16410 static const nir_search_variable search136_1 = {
   16411    { nir_search_value_variable, 0 },
   16412    0, /* a */
   16413    false,
   16414    nir_type_invalid,
   16415    NULL,
   16416 };
   16417 #include "compiler/nir/nir_search_helpers.h"
   16418 static const nir_search_expression search136 = {
   16419    { nir_search_value_expression, 0 },
   16420    false,
   16421    nir_op_ishr,
   16422    { &search136_0.value, &search136_1.value },
   16423    NULL,
   16424 };
   16425 
   16426 #include "compiler/nir/nir_search_helpers.h"
   16427 static const nir_search_constant replace136 = {
   16428    { nir_search_value_constant, 0 },
   16429    nir_type_int, { 0x0 /* 0 */ },
   16430 };
   16431 
   16432 #include "compiler/nir/nir_search_helpers.h"
   16433 static const nir_search_variable search137_0 = {
   16434    { nir_search_value_variable, 0 },
   16435    0, /* a */
   16436    false,
   16437    nir_type_invalid,
   16438    NULL,
   16439 };
   16440 
   16441 #include "compiler/nir/nir_search_helpers.h"
   16442 static const nir_search_constant search137_1 = {
   16443    { nir_search_value_constant, 0 },
   16444    nir_type_int, { 0x0 /* 0 */ },
   16445 };
   16446 #include "compiler/nir/nir_search_helpers.h"
   16447 static const nir_search_expression search137 = {
   16448    { nir_search_value_expression, 0 },
   16449    false,
   16450    nir_op_ishr,
   16451    { &search137_0.value, &search137_1.value },
   16452    NULL,
   16453 };
   16454 
   16455 #include "compiler/nir/nir_search_helpers.h"
   16456 static const nir_search_variable replace137 = {
   16457    { nir_search_value_variable, 0 },
   16458    0, /* a */
   16459    false,
   16460    nir_type_invalid,
   16461    NULL,
   16462 };
   16463 
   16464 static const struct transform nir_opt_algebraic_ishr_xforms[] = {
   16465    { &search136, &replace136.value, 0 },
   16466    { &search137, &replace137.value, 0 },
   16467 };
   16468 
   16469 #include "compiler/nir/nir_search_helpers.h"
   16470 static const nir_search_variable search102_0 = {
   16471    { nir_search_value_variable, 0 },
   16472    0, /* a */
   16473    false,
   16474    nir_type_invalid,
   16475    NULL,
   16476 };
   16477 
   16478 #include "compiler/nir/nir_search_helpers.h"
   16479 static const nir_search_variable search102_1 = {
   16480    { nir_search_value_variable, 0 },
   16481    1, /* b */
   16482    false,
   16483    nir_type_invalid,
   16484    NULL,
   16485 };
   16486 #include "compiler/nir/nir_search_helpers.h"
   16487 static const nir_search_expression search102 = {
   16488    { nir_search_value_expression, 0 },
   16489    false,
   16490    nir_op_slt,
   16491    { &search102_0.value, &search102_1.value },
   16492    NULL,
   16493 };
   16494 
   16495 #include "compiler/nir/nir_search_helpers.h"
   16496 static const nir_search_variable replace102_0_0 = {
   16497    { nir_search_value_variable, 0 },
   16498    0, /* a */
   16499    false,
   16500    nir_type_invalid,
   16501    NULL,
   16502 };
   16503 
   16504 #include "compiler/nir/nir_search_helpers.h"
   16505 static const nir_search_variable replace102_0_1 = {
   16506    { nir_search_value_variable, 0 },
   16507    1, /* b */
   16508    false,
   16509    nir_type_invalid,
   16510    NULL,
   16511 };
   16512 #include "compiler/nir/nir_search_helpers.h"
   16513 static const nir_search_expression replace102_0 = {
   16514    { nir_search_value_expression, 0 },
   16515    false,
   16516    nir_op_flt,
   16517    { &replace102_0_0.value, &replace102_0_1.value },
   16518    NULL,
   16519 };
   16520 #include "compiler/nir/nir_search_helpers.h"
   16521 static const nir_search_expression replace102 = {
   16522    { nir_search_value_expression, 0 },
   16523    false,
   16524    nir_op_b2f,
   16525    { &replace102_0.value },
   16526    NULL,
   16527 };
   16528 
   16529 static const struct transform nir_opt_algebraic_slt_xforms[] = {
   16530    { &search102, &replace102.value, 11 },
   16531 };
   16532 
   16533 #include "compiler/nir/nir_search_helpers.h"
   16534 static const nir_search_variable search183_0_0 = {
   16535    { nir_search_value_variable, 0 },
   16536    0, /* a */
   16537    false,
   16538    nir_type_invalid,
   16539    NULL,
   16540 };
   16541 #include "compiler/nir/nir_search_helpers.h"
   16542 static const nir_search_expression search183_0 = {
   16543    { nir_search_value_expression, 0 },
   16544    false,
   16545    nir_op_ftrunc,
   16546    { &search183_0_0.value },
   16547    NULL,
   16548 };
   16549 #include "compiler/nir/nir_search_helpers.h"
   16550 static const nir_search_expression search183 = {
   16551    { nir_search_value_expression, 0 },
   16552    false,
   16553    nir_op_f2i,
   16554    { &search183_0.value },
   16555    NULL,
   16556 };
   16557 
   16558 #include "compiler/nir/nir_search_helpers.h"
   16559 static const nir_search_variable replace183_0 = {
   16560    { nir_search_value_variable, 0 },
   16561    0, /* a */
   16562    false,
   16563    nir_type_invalid,
   16564    NULL,
   16565 };
   16566 #include "compiler/nir/nir_search_helpers.h"
   16567 static const nir_search_expression replace183 = {
   16568    { nir_search_value_expression, 0 },
   16569    false,
   16570    nir_op_f2i,
   16571    { &replace183_0.value },
   16572    NULL,
   16573 };
   16574 
   16575 static const struct transform nir_opt_algebraic_f2i_xforms[] = {
   16576    { &search183, &replace183.value, 0 },
   16577 };
   16578 
   16579 #include "compiler/nir/nir_search_helpers.h"
   16580 static const nir_search_constant search71_0 = {
   16581    { nir_search_value_constant, 0 },
   16582    nir_type_float, { 0x0 /* 0.0 */ },
   16583 };
   16584 
   16585 #include "compiler/nir/nir_search_helpers.h"
   16586 static const nir_search_variable search71_1_0 = {
   16587    { nir_search_value_variable, 0 },
   16588    0, /* a */
   16589    false,
   16590    nir_type_invalid,
   16591    NULL,
   16592 };
   16593 #include "compiler/nir/nir_search_helpers.h"
   16594 static const nir_search_expression search71_1 = {
   16595    { nir_search_value_expression, 0 },
   16596    false,
   16597    nir_op_fabs,
   16598    { &search71_1_0.value },
   16599    NULL,
   16600 };
   16601 #include "compiler/nir/nir_search_helpers.h"
   16602 static const nir_search_expression search71 = {
   16603    { nir_search_value_expression, 0 },
   16604    false,
   16605    nir_op_flt,
   16606    { &search71_0.value, &search71_1.value },
   16607    NULL,
   16608 };
   16609 
   16610 #include "compiler/nir/nir_search_helpers.h"
   16611 static const nir_search_variable replace71_0 = {
   16612    { nir_search_value_variable, 0 },
   16613    0, /* a */
   16614    false,
   16615    nir_type_invalid,
   16616    NULL,
   16617 };
   16618 
   16619 #include "compiler/nir/nir_search_helpers.h"
   16620 static const nir_search_constant replace71_1 = {
   16621    { nir_search_value_constant, 0 },
   16622    nir_type_float, { 0x0 /* 0.0 */ },
   16623 };
   16624 #include "compiler/nir/nir_search_helpers.h"
   16625 static const nir_search_expression replace71 = {
   16626    { nir_search_value_expression, 0 },
   16627    false,
   16628    nir_op_fne,
   16629    { &replace71_0.value, &replace71_1.value },
   16630    NULL,
   16631 };
   16632 
   16633 #include "compiler/nir/nir_search_helpers.h"
   16634 static const nir_search_variable search113_0_0_0 = {
   16635    { nir_search_value_variable, 0 },
   16636    0, /* a */
   16637    false,
   16638    nir_type_invalid,
   16639    NULL,
   16640 };
   16641 #include "compiler/nir/nir_search_helpers.h"
   16642 static const nir_search_expression search113_0_0 = {
   16643    { nir_search_value_expression, 0 },
   16644    false,
   16645    nir_op_b2f,
   16646    { &search113_0_0_0.value },
   16647    NULL,
   16648 };
   16649 #include "compiler/nir/nir_search_helpers.h"
   16650 static const nir_search_expression search113_0 = {
   16651    { nir_search_value_expression, 0 },
   16652    false,
   16653    nir_op_fneg,
   16654    { &search113_0_0.value },
   16655    NULL,
   16656 };
   16657 
   16658 #include "compiler/nir/nir_search_helpers.h"
   16659 static const nir_search_constant search113_1 = {
   16660    { nir_search_value_constant, 0 },
   16661    nir_type_int, { 0x0 /* 0 */ },
   16662 };
   16663 #include "compiler/nir/nir_search_helpers.h"
   16664 static const nir_search_expression search113 = {
   16665    { nir_search_value_expression, 0 },
   16666    false,
   16667    nir_op_flt,
   16668    { &search113_0.value, &search113_1.value },
   16669    NULL,
   16670 };
   16671 
   16672 #include "compiler/nir/nir_search_helpers.h"
   16673 static const nir_search_variable replace113 = {
   16674    { nir_search_value_variable, 0 },
   16675    0, /* a */
   16676    false,
   16677    nir_type_invalid,
   16678    NULL,
   16679 };
   16680 
   16681 #include "compiler/nir/nir_search_helpers.h"
   16682 static const nir_search_constant search114_0_0 = {
   16683    { nir_search_value_constant, 0 },
   16684    nir_type_float, { 0x0 /* 0.0 */ },
   16685 };
   16686 
   16687 #include "compiler/nir/nir_search_helpers.h"
   16688 static const nir_search_variable search114_0_1_0 = {
   16689    { nir_search_value_variable, 0 },
   16690    0, /* a */
   16691    false,
   16692    nir_type_invalid,
   16693    NULL,
   16694 };
   16695 #include "compiler/nir/nir_search_helpers.h"
   16696 static const nir_search_expression search114_0_1 = {
   16697    { nir_search_value_expression, 0 },
   16698    false,
   16699    nir_op_b2f,
   16700    { &search114_0_1_0.value },
   16701    NULL,
   16702 };
   16703 #include "compiler/nir/nir_search_helpers.h"
   16704 static const nir_search_expression search114_0 = {
   16705    { nir_search_value_expression, 0 },
   16706    false,
   16707    nir_op_fsub,
   16708    { &search114_0_0.value, &search114_0_1.value },
   16709    NULL,
   16710 };
   16711 
   16712 #include "compiler/nir/nir_search_helpers.h"
   16713 static const nir_search_constant search114_1 = {
   16714    { nir_search_value_constant, 0 },
   16715    nir_type_int, { 0x0 /* 0 */ },
   16716 };
   16717 #include "compiler/nir/nir_search_helpers.h"
   16718 static const nir_search_expression search114 = {
   16719    { nir_search_value_expression, 0 },
   16720    false,
   16721    nir_op_flt,
   16722    { &search114_0.value, &search114_1.value },
   16723    NULL,
   16724 };
   16725 
   16726 #include "compiler/nir/nir_search_helpers.h"
   16727 static const nir_search_variable replace114 = {
   16728    { nir_search_value_variable, 0 },
   16729    0, /* a */
   16730    false,
   16731    nir_type_invalid,
   16732    NULL,
   16733 };
   16734 
   16735 #include "compiler/nir/nir_search_helpers.h"
   16736 static const nir_search_variable search242_0_0 = {
   16737    { nir_search_value_variable, 0 },
   16738    0, /* a */
   16739    false,
   16740    nir_type_invalid,
   16741    NULL,
   16742 };
   16743 
   16744 #include "compiler/nir/nir_search_helpers.h"
   16745 static const nir_search_variable search242_0_1 = {
   16746    { nir_search_value_variable, 0 },
   16747    1, /* b */
   16748    true,
   16749    nir_type_invalid,
   16750    NULL,
   16751 };
   16752 
   16753 #include "compiler/nir/nir_search_helpers.h"
   16754 static const nir_search_variable search242_0_2 = {
   16755    { nir_search_value_variable, 0 },
   16756    2, /* c */
   16757    true,
   16758    nir_type_invalid,
   16759    NULL,
   16760 };
   16761 #include "compiler/nir/nir_search_helpers.h"
   16762 static const nir_search_expression search242_0 = {
   16763    { nir_search_value_expression, 0 },
   16764    false,
   16765    nir_op_bcsel,
   16766    { &search242_0_0.value, &search242_0_1.value, &search242_0_2.value },
   16767    NULL,
   16768 };
   16769 
   16770 #include "compiler/nir/nir_search_helpers.h"
   16771 static const nir_search_variable search242_1 = {
   16772    { nir_search_value_variable, 0 },
   16773    3, /* d */
   16774    true,
   16775    nir_type_invalid,
   16776    NULL,
   16777 };
   16778 #include "compiler/nir/nir_search_helpers.h"
   16779 static const nir_search_expression search242 = {
   16780    { nir_search_value_expression, 0 },
   16781    false,
   16782    nir_op_flt,
   16783    { &search242_0.value, &search242_1.value },
   16784    NULL,
   16785 };
   16786 
   16787 #include "compiler/nir/nir_search_helpers.h"
   16788 static const nir_search_variable replace242_0 = {
   16789    { nir_search_value_variable, 0 },
   16790    0, /* a */
   16791    false,
   16792    nir_type_invalid,
   16793    NULL,
   16794 };
   16795 
   16796 #include "compiler/nir/nir_search_helpers.h"
   16797 static const nir_search_variable replace242_1_0 = {
   16798    { nir_search_value_variable, 0 },
   16799    1, /* b */
   16800    false,
   16801    nir_type_invalid,
   16802    NULL,
   16803 };
   16804 
   16805 #include "compiler/nir/nir_search_helpers.h"
   16806 static const nir_search_variable replace242_1_1 = {
   16807    { nir_search_value_variable, 0 },
   16808    3, /* d */
   16809    false,
   16810    nir_type_invalid,
   16811    NULL,
   16812 };
   16813 #include "compiler/nir/nir_search_helpers.h"
   16814 static const nir_search_expression replace242_1 = {
   16815    { nir_search_value_expression, 0 },
   16816    false,
   16817    nir_op_flt,
   16818    { &replace242_1_0.value, &replace242_1_1.value },
   16819    NULL,
   16820 };
   16821 
   16822 #include "compiler/nir/nir_search_helpers.h"
   16823 static const nir_search_variable replace242_2_0 = {
   16824    { nir_search_value_variable, 0 },
   16825    2, /* c */
   16826    false,
   16827    nir_type_invalid,
   16828    NULL,
   16829 };
   16830 
   16831 #include "compiler/nir/nir_search_helpers.h"
   16832 static const nir_search_variable replace242_2_1 = {
   16833    { nir_search_value_variable, 0 },
   16834    3, /* d */
   16835    false,
   16836    nir_type_invalid,
   16837    NULL,
   16838 };
   16839 #include "compiler/nir/nir_search_helpers.h"
   16840 static const nir_search_expression replace242_2 = {
   16841    { nir_search_value_expression, 0 },
   16842    false,
   16843    nir_op_flt,
   16844    { &replace242_2_0.value, &replace242_2_1.value },
   16845    NULL,
   16846 };
   16847 #include "compiler/nir/nir_search_helpers.h"
   16848 static const nir_search_expression replace242 = {
   16849    { nir_search_value_expression, 0 },
   16850    false,
   16851    nir_op_bcsel,
   16852    { &replace242_0.value, &replace242_1.value, &replace242_2.value },
   16853    NULL,
   16854 };
   16855 
   16856 #include "compiler/nir/nir_search_helpers.h"
   16857 static const nir_search_variable search243_0 = {
   16858    { nir_search_value_variable, 0 },
   16859    0, /* d */
   16860    true,
   16861    nir_type_invalid,
   16862    NULL,
   16863 };
   16864 
   16865 #include "compiler/nir/nir_search_helpers.h"
   16866 static const nir_search_variable search243_1_0 = {
   16867    { nir_search_value_variable, 0 },
   16868    1, /* a */
   16869    false,
   16870    nir_type_invalid,
   16871    NULL,
   16872 };
   16873 
   16874 #include "compiler/nir/nir_search_helpers.h"
   16875 static const nir_search_variable search243_1_1 = {
   16876    { nir_search_value_variable, 0 },
   16877    2, /* b */
   16878    true,
   16879    nir_type_invalid,
   16880    NULL,
   16881 };
   16882 
   16883 #include "compiler/nir/nir_search_helpers.h"
   16884 static const nir_search_variable search243_1_2 = {
   16885    { nir_search_value_variable, 0 },
   16886    3, /* c */
   16887    true,
   16888    nir_type_invalid,
   16889    NULL,
   16890 };
   16891 #include "compiler/nir/nir_search_helpers.h"
   16892 static const nir_search_expression search243_1 = {
   16893    { nir_search_value_expression, 0 },
   16894    false,
   16895    nir_op_bcsel,
   16896    { &search243_1_0.value, &search243_1_1.value, &search243_1_2.value },
   16897    NULL,
   16898 };
   16899 #include "compiler/nir/nir_search_helpers.h"
   16900 static const nir_search_expression search243 = {
   16901    { nir_search_value_expression, 0 },
   16902    false,
   16903    nir_op_flt,
   16904    { &search243_0.value, &search243_1.value },
   16905    NULL,
   16906 };
   16907 
   16908 #include "compiler/nir/nir_search_helpers.h"
   16909 static const nir_search_variable replace243_0 = {
   16910    { nir_search_value_variable, 0 },
   16911    1, /* a */
   16912    false,
   16913    nir_type_invalid,
   16914    NULL,
   16915 };
   16916 
   16917 #include "compiler/nir/nir_search_helpers.h"
   16918 static const nir_search_variable replace243_1_0 = {
   16919    { nir_search_value_variable, 0 },
   16920    0, /* d */
   16921    false,
   16922    nir_type_invalid,
   16923    NULL,
   16924 };
   16925 
   16926 #include "compiler/nir/nir_search_helpers.h"
   16927 static const nir_search_variable replace243_1_1 = {
   16928    { nir_search_value_variable, 0 },
   16929    2, /* b */
   16930    false,
   16931    nir_type_invalid,
   16932    NULL,
   16933 };
   16934 #include "compiler/nir/nir_search_helpers.h"
   16935 static const nir_search_expression replace243_1 = {
   16936    { nir_search_value_expression, 0 },
   16937    false,
   16938    nir_op_flt,
   16939    { &replace243_1_0.value, &replace243_1_1.value },
   16940    NULL,
   16941 };
   16942 
   16943 #include "compiler/nir/nir_search_helpers.h"
   16944 static const nir_search_variable replace243_2_0 = {
   16945    { nir_search_value_variable, 0 },
   16946    0, /* d */
   16947    false,
   16948    nir_type_invalid,
   16949    NULL,
   16950 };
   16951 
   16952 #include "compiler/nir/nir_search_helpers.h"
   16953 static const nir_search_variable replace243_2_1 = {
   16954    { nir_search_value_variable, 0 },
   16955    3, /* c */
   16956    false,
   16957    nir_type_invalid,
   16958    NULL,
   16959 };
   16960 #include "compiler/nir/nir_search_helpers.h"
   16961 static const nir_search_expression replace243_2 = {
   16962    { nir_search_value_expression, 0 },
   16963    false,
   16964    nir_op_flt,
   16965    { &replace243_2_0.value, &replace243_2_1.value },
   16966    NULL,
   16967 };
   16968 #include "compiler/nir/nir_search_helpers.h"
   16969 static const nir_search_expression replace243 = {
   16970    { nir_search_value_expression, 0 },
   16971    false,
   16972    nir_op_bcsel,
   16973    { &replace243_0.value, &replace243_1.value, &replace243_2.value },
   16974    NULL,
   16975 };
   16976 
   16977 static const struct transform nir_opt_algebraic_flt_xforms[] = {
   16978    { &search71, &replace71.value, 0 },
   16979    { &search113, &replace113.value, 0 },
   16980    { &search114, &replace114.value, 0 },
   16981    { &search242, &replace242.value, 0 },
   16982    { &search243, &replace243.value, 0 },
   16983 };
   16984 
   16985 #include "compiler/nir/nir_search_helpers.h"
   16986 static const nir_search_variable search119_0 = {
   16987    { nir_search_value_variable, 0 },
   16988    0, /* a */
   16989    false,
   16990    nir_type_invalid,
   16991    NULL,
   16992 };
   16993 
   16994 #include "compiler/nir/nir_search_helpers.h"
   16995 static const nir_search_variable search119_1 = {
   16996    { nir_search_value_variable, 0 },
   16997    0, /* a */
   16998    false,
   16999    nir_type_invalid,
   17000    NULL,
   17001 };
   17002 #include "compiler/nir/nir_search_helpers.h"
   17003 static const nir_search_expression search119 = {
   17004    { nir_search_value_expression, 0 },
   17005    false,
   17006    nir_op_ult,
   17007    { &search119_0.value, &search119_1.value },
   17008    NULL,
   17009 };
   17010 
   17011 #include "compiler/nir/nir_search_helpers.h"
   17012 static const nir_search_constant replace119 = {
   17013    { nir_search_value_constant, 32 },
   17014    nir_type_bool32, { NIR_FALSE /* False */ },
   17015 };
   17016 
   17017 #include "compiler/nir/nir_search_helpers.h"
   17018 static const nir_search_variable search258_0_0 = {
   17019    { nir_search_value_variable, 0 },
   17020    0, /* a */
   17021    false,
   17022    nir_type_invalid,
   17023    NULL,
   17024 };
   17025 
   17026 #include "compiler/nir/nir_search_helpers.h"
   17027 static const nir_search_variable search258_0_1 = {
   17028    { nir_search_value_variable, 0 },
   17029    1, /* b */
   17030    true,
   17031    nir_type_invalid,
   17032    NULL,
   17033 };
   17034 
   17035 #include "compiler/nir/nir_search_helpers.h"
   17036 static const nir_search_variable search258_0_2 = {
   17037    { nir_search_value_variable, 0 },
   17038    2, /* c */
   17039    true,
   17040    nir_type_invalid,
   17041    NULL,
   17042 };
   17043 #include "compiler/nir/nir_search_helpers.h"
   17044 static const nir_search_expression search258_0 = {
   17045    { nir_search_value_expression, 0 },
   17046    false,
   17047    nir_op_bcsel,
   17048    { &search258_0_0.value, &search258_0_1.value, &search258_0_2.value },
   17049    NULL,
   17050 };
   17051 
   17052 #include "compiler/nir/nir_search_helpers.h"
   17053 static const nir_search_variable search258_1 = {
   17054    { nir_search_value_variable, 0 },
   17055    3, /* d */
   17056    true,
   17057    nir_type_invalid,
   17058    NULL,
   17059 };
   17060 #include "compiler/nir/nir_search_helpers.h"
   17061 static const nir_search_expression search258 = {
   17062    { nir_search_value_expression, 0 },
   17063    false,
   17064    nir_op_ult,
   17065    { &search258_0.value, &search258_1.value },
   17066    NULL,
   17067 };
   17068 
   17069 #include "compiler/nir/nir_search_helpers.h"
   17070 static const nir_search_variable replace258_0 = {
   17071    { nir_search_value_variable, 0 },
   17072    0, /* a */
   17073    false,
   17074    nir_type_invalid,
   17075    NULL,
   17076 };
   17077 
   17078 #include "compiler/nir/nir_search_helpers.h"
   17079 static const nir_search_variable replace258_1_0 = {
   17080    { nir_search_value_variable, 0 },
   17081    1, /* b */
   17082    false,
   17083    nir_type_invalid,
   17084    NULL,
   17085 };
   17086 
   17087 #include "compiler/nir/nir_search_helpers.h"
   17088 static const nir_search_variable replace258_1_1 = {
   17089    { nir_search_value_variable, 0 },
   17090    3, /* d */
   17091    false,
   17092    nir_type_invalid,
   17093    NULL,
   17094 };
   17095 #include "compiler/nir/nir_search_helpers.h"
   17096 static const nir_search_expression replace258_1 = {
   17097    { nir_search_value_expression, 0 },
   17098    false,
   17099    nir_op_ult,
   17100    { &replace258_1_0.value, &replace258_1_1.value },
   17101    NULL,
   17102 };
   17103 
   17104 #include "compiler/nir/nir_search_helpers.h"
   17105 static const nir_search_variable replace258_2_0 = {
   17106    { nir_search_value_variable, 0 },
   17107    2, /* c */
   17108    false,
   17109    nir_type_invalid,
   17110    NULL,
   17111 };
   17112 
   17113 #include "compiler/nir/nir_search_helpers.h"
   17114 static const nir_search_variable replace258_2_1 = {
   17115    { nir_search_value_variable, 0 },
   17116    3, /* d */
   17117    false,
   17118    nir_type_invalid,
   17119    NULL,
   17120 };
   17121 #include "compiler/nir/nir_search_helpers.h"
   17122 static const nir_search_expression replace258_2 = {
   17123    { nir_search_value_expression, 0 },
   17124    false,
   17125    nir_op_ult,
   17126    { &replace258_2_0.value, &replace258_2_1.value },
   17127    NULL,
   17128 };
   17129 #include "compiler/nir/nir_search_helpers.h"
   17130 static const nir_search_expression replace258 = {
   17131    { nir_search_value_expression, 0 },
   17132    false,
   17133    nir_op_bcsel,
   17134    { &replace258_0.value, &replace258_1.value, &replace258_2.value },
   17135    NULL,
   17136 };
   17137 
   17138 #include "compiler/nir/nir_search_helpers.h"
   17139 static const nir_search_variable search259_0 = {
   17140    { nir_search_value_variable, 0 },
   17141    0, /* d */
   17142    true,
   17143    nir_type_invalid,
   17144    NULL,
   17145 };
   17146 
   17147 #include "compiler/nir/nir_search_helpers.h"
   17148 static const nir_search_variable search259_1_0 = {
   17149    { nir_search_value_variable, 0 },
   17150    1, /* a */
   17151    false,
   17152    nir_type_invalid,
   17153    NULL,
   17154 };
   17155 
   17156 #include "compiler/nir/nir_search_helpers.h"
   17157 static const nir_search_variable search259_1_1 = {
   17158    { nir_search_value_variable, 0 },
   17159    2, /* b */
   17160    true,
   17161    nir_type_invalid,
   17162    NULL,
   17163 };
   17164 
   17165 #include "compiler/nir/nir_search_helpers.h"
   17166 static const nir_search_variable search259_1_2 = {
   17167    { nir_search_value_variable, 0 },
   17168    3, /* c */
   17169    true,
   17170    nir_type_invalid,
   17171    NULL,
   17172 };
   17173 #include "compiler/nir/nir_search_helpers.h"
   17174 static const nir_search_expression search259_1 = {
   17175    { nir_search_value_expression, 0 },
   17176    false,
   17177    nir_op_bcsel,
   17178    { &search259_1_0.value, &search259_1_1.value, &search259_1_2.value },
   17179    NULL,
   17180 };
   17181 #include "compiler/nir/nir_search_helpers.h"
   17182 static const nir_search_expression search259 = {
   17183    { nir_search_value_expression, 0 },
   17184    false,
   17185    nir_op_ult,
   17186    { &search259_0.value, &search259_1.value },
   17187    NULL,
   17188 };
   17189 
   17190 #include "compiler/nir/nir_search_helpers.h"
   17191 static const nir_search_variable replace259_0 = {
   17192    { nir_search_value_variable, 0 },
   17193    1, /* a */
   17194    false,
   17195    nir_type_invalid,
   17196    NULL,
   17197 };
   17198 
   17199 #include "compiler/nir/nir_search_helpers.h"
   17200 static const nir_search_variable replace259_1_0 = {
   17201    { nir_search_value_variable, 0 },
   17202    0, /* d */
   17203    false,
   17204    nir_type_invalid,
   17205    NULL,
   17206 };
   17207 
   17208 #include "compiler/nir/nir_search_helpers.h"
   17209 static const nir_search_variable replace259_1_1 = {
   17210    { nir_search_value_variable, 0 },
   17211    2, /* b */
   17212    false,
   17213    nir_type_invalid,
   17214    NULL,
   17215 };
   17216 #include "compiler/nir/nir_search_helpers.h"
   17217 static const nir_search_expression replace259_1 = {
   17218    { nir_search_value_expression, 0 },
   17219    false,
   17220    nir_op_ult,
   17221    { &replace259_1_0.value, &replace259_1_1.value },
   17222    NULL,
   17223 };
   17224 
   17225 #include "compiler/nir/nir_search_helpers.h"
   17226 static const nir_search_variable replace259_2_0 = {
   17227    { nir_search_value_variable, 0 },
   17228    0, /* d */
   17229    false,
   17230    nir_type_invalid,
   17231    NULL,
   17232 };
   17233 
   17234 #include "compiler/nir/nir_search_helpers.h"
   17235 static const nir_search_variable replace259_2_1 = {
   17236    { nir_search_value_variable, 0 },
   17237    3, /* c */
   17238    false,
   17239    nir_type_invalid,
   17240    NULL,
   17241 };
   17242 #include "compiler/nir/nir_search_helpers.h"
   17243 static const nir_search_expression replace259_2 = {
   17244    { nir_search_value_expression, 0 },
   17245    false,
   17246    nir_op_ult,
   17247    { &replace259_2_0.value, &replace259_2_1.value },
   17248    NULL,
   17249 };
   17250 #include "compiler/nir/nir_search_helpers.h"
   17251 static const nir_search_expression replace259 = {
   17252    { nir_search_value_expression, 0 },
   17253    false,
   17254    nir_op_bcsel,
   17255    { &replace259_0.value, &replace259_1.value, &replace259_2.value },
   17256    NULL,
   17257 };
   17258 
   17259 static const struct transform nir_opt_algebraic_ult_xforms[] = {
   17260    { &search119, &replace119.value, 0 },
   17261    { &search258, &replace258.value, 0 },
   17262    { &search259, &replace259.value, 0 },
   17263 };
   17264 
   17265 #include "compiler/nir/nir_search_helpers.h"
   17266 static const nir_search_variable search195_0 = {
   17267    { nir_search_value_variable, 0 },
   17268    0, /* a */
   17269    false,
   17270    nir_type_invalid,
   17271    NULL,
   17272 };
   17273 
   17274 #include "compiler/nir/nir_search_helpers.h"
   17275 static const nir_search_constant search195_1_0 = {
   17276    { nir_search_value_constant, 0 },
   17277    nir_type_float, { 0x0 /* 0.0 */ },
   17278 };
   17279 
   17280 #include "compiler/nir/nir_search_helpers.h"
   17281 static const nir_search_variable search195_1_1 = {
   17282    { nir_search_value_variable, 0 },
   17283    1, /* b */
   17284    false,
   17285    nir_type_invalid,
   17286    NULL,
   17287 };
   17288 #include "compiler/nir/nir_search_helpers.h"
   17289 static const nir_search_expression search195_1 = {
   17290    { nir_search_value_expression, 0 },
   17291    false,
   17292    nir_op_fsub,
   17293    { &search195_1_0.value, &search195_1_1.value },
   17294    NULL,
   17295 };
   17296 #include "compiler/nir/nir_search_helpers.h"
   17297 static const nir_search_expression search195 = {
   17298    { nir_search_value_expression, 0 },
   17299    true,
   17300    nir_op_fsub,
   17301    { &search195_0.value, &search195_1.value },
   17302    NULL,
   17303 };
   17304 
   17305 #include "compiler/nir/nir_search_helpers.h"
   17306 static const nir_search_variable replace195_0 = {
   17307    { nir_search_value_variable, 0 },
   17308    0, /* a */
   17309    false,
   17310    nir_type_invalid,
   17311    NULL,
   17312 };
   17313 
   17314 #include "compiler/nir/nir_search_helpers.h"
   17315 static const nir_search_variable replace195_1 = {
   17316    { nir_search_value_variable, 0 },
   17317    1, /* b */
   17318    false,
   17319    nir_type_invalid,
   17320    NULL,
   17321 };
   17322 #include "compiler/nir/nir_search_helpers.h"
   17323 static const nir_search_expression replace195 = {
   17324    { nir_search_value_expression, 0 },
   17325    false,
   17326    nir_op_fadd,
   17327    { &replace195_0.value, &replace195_1.value },
   17328    NULL,
   17329 };
   17330 
   17331 #include "compiler/nir/nir_search_helpers.h"
   17332 static const nir_search_variable search199_0 = {
   17333    { nir_search_value_variable, 0 },
   17334    0, /* a */
   17335    false,
   17336    nir_type_invalid,
   17337    NULL,
   17338 };
   17339 
   17340 #include "compiler/nir/nir_search_helpers.h"
   17341 static const nir_search_variable search199_1 = {
   17342    { nir_search_value_variable, 0 },
   17343    1, /* b */
   17344    false,
   17345    nir_type_invalid,
   17346    NULL,
   17347 };
   17348 #include "compiler/nir/nir_search_helpers.h"
   17349 static const nir_search_expression search199 = {
   17350    { nir_search_value_expression, 0 },
   17351    false,
   17352    nir_op_fsub,
   17353    { &search199_0.value, &search199_1.value },
   17354    NULL,
   17355 };
   17356 
   17357 #include "compiler/nir/nir_search_helpers.h"
   17358 static const nir_search_variable replace199_0 = {
   17359    { nir_search_value_variable, 0 },
   17360    0, /* a */
   17361    false,
   17362    nir_type_invalid,
   17363    NULL,
   17364 };
   17365 
   17366 #include "compiler/nir/nir_search_helpers.h"
   17367 static const nir_search_variable replace199_1_0 = {
   17368    { nir_search_value_variable, 0 },
   17369    1, /* b */
   17370    false,
   17371    nir_type_invalid,
   17372    NULL,
   17373 };
   17374 #include "compiler/nir/nir_search_helpers.h"
   17375 static const nir_search_expression replace199_1 = {
   17376    { nir_search_value_expression, 0 },
   17377    false,
   17378    nir_op_fneg,
   17379    { &replace199_1_0.value },
   17380    NULL,
   17381 };
   17382 #include "compiler/nir/nir_search_helpers.h"
   17383 static const nir_search_expression replace199 = {
   17384    { nir_search_value_expression, 0 },
   17385    false,
   17386    nir_op_fadd,
   17387    { &replace199_0.value, &replace199_1.value },
   17388    NULL,
   17389 };
   17390 
   17391 static const struct transform nir_opt_algebraic_fsub_xforms[] = {
   17392    { &search195, &replace195.value, 0 },
   17393    { &search199, &replace199.value, 19 },
   17394 };
   17395 
   17396 #include "compiler/nir/nir_search_helpers.h"
   17397 static const nir_search_variable search10_0_0 = {
   17398    { nir_search_value_variable, 0 },
   17399    0, /* a */
   17400    false,
   17401    nir_type_invalid,
   17402    NULL,
   17403 };
   17404 #include "compiler/nir/nir_search_helpers.h"
   17405 static const nir_search_expression search10_0 = {
   17406    { nir_search_value_expression, 0 },
   17407    false,
   17408    nir_op_fneg,
   17409    { &search10_0_0.value },
   17410    NULL,
   17411 };
   17412 #include "compiler/nir/nir_search_helpers.h"
   17413 static const nir_search_expression search10 = {
   17414    { nir_search_value_expression, 0 },
   17415    false,
   17416    nir_op_fneg,
   17417    { &search10_0.value },
   17418    NULL,
   17419 };
   17420 
   17421 #include "compiler/nir/nir_search_helpers.h"
   17422 static const nir_search_variable replace10 = {
   17423    { nir_search_value_variable, 0 },
   17424    0, /* a */
   17425    false,
   17426    nir_type_invalid,
   17427    NULL,
   17428 };
   17429 
   17430 #include "compiler/nir/nir_search_helpers.h"
   17431 static const nir_search_variable search201_0 = {
   17432    { nir_search_value_variable, 0 },
   17433    0, /* a */
   17434    false,
   17435    nir_type_invalid,
   17436    NULL,
   17437 };
   17438 #include "compiler/nir/nir_search_helpers.h"
   17439 static const nir_search_expression search201 = {
   17440    { nir_search_value_expression, 0 },
   17441    false,
   17442    nir_op_fneg,
   17443    { &search201_0.value },
   17444    NULL,
   17445 };
   17446 
   17447 #include "compiler/nir/nir_search_helpers.h"
   17448 static const nir_search_constant replace201_0 = {
   17449    { nir_search_value_constant, 0 },
   17450    nir_type_float, { 0x0 /* 0.0 */ },
   17451 };
   17452 
   17453 #include "compiler/nir/nir_search_helpers.h"
   17454 static const nir_search_variable replace201_1 = {
   17455    { nir_search_value_variable, 0 },
   17456    0, /* a */
   17457    false,
   17458    nir_type_invalid,
   17459    NULL,
   17460 };
   17461 #include "compiler/nir/nir_search_helpers.h"
   17462 static const nir_search_expression replace201 = {
   17463    { nir_search_value_expression, 0 },
   17464    false,
   17465    nir_op_fsub,
   17466    { &replace201_0.value, &replace201_1.value },
   17467    NULL,
   17468 };
   17469 
   17470 static const struct transform nir_opt_algebraic_fneg_xforms[] = {
   17471    { &search10, &replace10.value, 0 },
   17472    { &search201, &replace201.value, 20 },
   17473 };
   17474 
   17475 #include "compiler/nir/nir_search_helpers.h"
   17476 static const nir_search_variable search106_0_0 = {
   17477    { nir_search_value_variable, 0 },
   17478    0, /* a */
   17479    false,
   17480    nir_type_invalid,
   17481    NULL,
   17482 };
   17483 #include "compiler/nir/nir_search_helpers.h"
   17484 static const nir_search_expression search106_0 = {
   17485    { nir_search_value_expression, 0 },
   17486    false,
   17487    nir_op_fneg,
   17488    { &search106_0_0.value },
   17489    NULL,
   17490 };
   17491 
   17492 #include "compiler/nir/nir_search_helpers.h"
   17493 static const nir_search_variable search106_1 = {
   17494    { nir_search_value_variable, 0 },
   17495    0, /* a */
   17496    false,
   17497    nir_type_invalid,
   17498    NULL,
   17499 };
   17500 #include "compiler/nir/nir_search_helpers.h"
   17501 static const nir_search_expression search106 = {
   17502    { nir_search_value_expression, 0 },
   17503    false,
   17504    nir_op_fne,
   17505    { &search106_0.value, &search106_1.value },
   17506    NULL,
   17507 };
   17508 
   17509 #include "compiler/nir/nir_search_helpers.h"
   17510 static const nir_search_variable replace106_0 = {
   17511    { nir_search_value_variable, 0 },
   17512    0, /* a */
   17513    false,
   17514    nir_type_invalid,
   17515    NULL,
   17516 };
   17517 
   17518 #include "compiler/nir/nir_search_helpers.h"
   17519 static const nir_search_constant replace106_1 = {
   17520    { nir_search_value_constant, 0 },
   17521    nir_type_float, { 0x0 /* 0.0 */ },
   17522 };
   17523 #include "compiler/nir/nir_search_helpers.h"
   17524 static const nir_search_expression replace106 = {
   17525    { nir_search_value_expression, 0 },
   17526    false,
   17527    nir_op_fne,
   17528    { &replace106_0.value, &replace106_1.value },
   17529    NULL,
   17530 };
   17531 
   17532 #include "compiler/nir/nir_search_helpers.h"
   17533 static const nir_search_variable search248_0_0 = {
   17534    { nir_search_value_variable, 0 },
   17535    0, /* a */
   17536    false,
   17537    nir_type_invalid,
   17538    NULL,
   17539 };
   17540 
   17541 #include "compiler/nir/nir_search_helpers.h"
   17542 static const nir_search_variable search248_0_1 = {
   17543    { nir_search_value_variable, 0 },
   17544    1, /* b */
   17545    true,
   17546    nir_type_invalid,
   17547    NULL,
   17548 };
   17549 
   17550 #include "compiler/nir/nir_search_helpers.h"
   17551 static const nir_search_variable search248_0_2 = {
   17552    { nir_search_value_variable, 0 },
   17553    2, /* c */
   17554    true,
   17555    nir_type_invalid,
   17556    NULL,
   17557 };
   17558 #include "compiler/nir/nir_search_helpers.h"
   17559 static const nir_search_expression search248_0 = {
   17560    { nir_search_value_expression, 0 },
   17561    false,
   17562    nir_op_bcsel,
   17563    { &search248_0_0.value, &search248_0_1.value, &search248_0_2.value },
   17564    NULL,
   17565 };
   17566 
   17567 #include "compiler/nir/nir_search_helpers.h"
   17568 static const nir_search_variable search248_1 = {
   17569    { nir_search_value_variable, 0 },
   17570    3, /* d */
   17571    true,
   17572    nir_type_invalid,
   17573    NULL,
   17574 };
   17575 #include "compiler/nir/nir_search_helpers.h"
   17576 static const nir_search_expression search248 = {
   17577    { nir_search_value_expression, 0 },
   17578    false,
   17579    nir_op_fne,
   17580    { &search248_0.value, &search248_1.value },
   17581    NULL,
   17582 };
   17583 
   17584 #include "compiler/nir/nir_search_helpers.h"
   17585 static const nir_search_variable replace248_0 = {
   17586    { nir_search_value_variable, 0 },
   17587    0, /* a */
   17588    false,
   17589    nir_type_invalid,
   17590    NULL,
   17591 };
   17592 
   17593 #include "compiler/nir/nir_search_helpers.h"
   17594 static const nir_search_variable replace248_1_0 = {
   17595    { nir_search_value_variable, 0 },
   17596    1, /* b */
   17597    false,
   17598    nir_type_invalid,
   17599    NULL,
   17600 };
   17601 
   17602 #include "compiler/nir/nir_search_helpers.h"
   17603 static const nir_search_variable replace248_1_1 = {
   17604    { nir_search_value_variable, 0 },
   17605    3, /* d */
   17606    false,
   17607    nir_type_invalid,
   17608    NULL,
   17609 };
   17610 #include "compiler/nir/nir_search_helpers.h"
   17611 static const nir_search_expression replace248_1 = {
   17612    { nir_search_value_expression, 0 },
   17613    false,
   17614    nir_op_fne,
   17615    { &replace248_1_0.value, &replace248_1_1.value },
   17616    NULL,
   17617 };
   17618 
   17619 #include "compiler/nir/nir_search_helpers.h"
   17620 static const nir_search_variable replace248_2_0 = {
   17621    { nir_search_value_variable, 0 },
   17622    2, /* c */
   17623    false,
   17624    nir_type_invalid,
   17625    NULL,
   17626 };
   17627 
   17628 #include "compiler/nir/nir_search_helpers.h"
   17629 static const nir_search_variable replace248_2_1 = {
   17630    { nir_search_value_variable, 0 },
   17631    3, /* d */
   17632    false,
   17633    nir_type_invalid,
   17634    NULL,
   17635 };
   17636 #include "compiler/nir/nir_search_helpers.h"
   17637 static const nir_search_expression replace248_2 = {
   17638    { nir_search_value_expression, 0 },
   17639    false,
   17640    nir_op_fne,
   17641    { &replace248_2_0.value, &replace248_2_1.value },
   17642    NULL,
   17643 };
   17644 #include "compiler/nir/nir_search_helpers.h"
   17645 static const nir_search_expression replace248 = {
   17646    { nir_search_value_expression, 0 },
   17647    false,
   17648    nir_op_bcsel,
   17649    { &replace248_0.value, &replace248_1.value, &replace248_2.value },
   17650    NULL,
   17651 };
   17652 
   17653 #include "compiler/nir/nir_search_helpers.h"
   17654 static const nir_search_variable search249_0 = {
   17655    { nir_search_value_variable, 0 },
   17656    0, /* d */
   17657    true,
   17658    nir_type_invalid,
   17659    NULL,
   17660 };
   17661 
   17662 #include "compiler/nir/nir_search_helpers.h"
   17663 static const nir_search_variable search249_1_0 = {
   17664    { nir_search_value_variable, 0 },
   17665    1, /* a */
   17666    false,
   17667    nir_type_invalid,
   17668    NULL,
   17669 };
   17670 
   17671 #include "compiler/nir/nir_search_helpers.h"
   17672 static const nir_search_variable search249_1_1 = {
   17673    { nir_search_value_variable, 0 },
   17674    2, /* b */
   17675    true,
   17676    nir_type_invalid,
   17677    NULL,
   17678 };
   17679 
   17680 #include "compiler/nir/nir_search_helpers.h"
   17681 static const nir_search_variable search249_1_2 = {
   17682    { nir_search_value_variable, 0 },
   17683    3, /* c */
   17684    true,
   17685    nir_type_invalid,
   17686    NULL,
   17687 };
   17688 #include "compiler/nir/nir_search_helpers.h"
   17689 static const nir_search_expression search249_1 = {
   17690    { nir_search_value_expression, 0 },
   17691    false,
   17692    nir_op_bcsel,
   17693    { &search249_1_0.value, &search249_1_1.value, &search249_1_2.value },
   17694    NULL,
   17695 };
   17696 #include "compiler/nir/nir_search_helpers.h"
   17697 static const nir_search_expression search249 = {
   17698    { nir_search_value_expression, 0 },
   17699    false,
   17700    nir_op_fne,
   17701    { &search249_0.value, &search249_1.value },
   17702    NULL,
   17703 };
   17704 
   17705 #include "compiler/nir/nir_search_helpers.h"
   17706 static const nir_search_variable replace249_0 = {
   17707    { nir_search_value_variable, 0 },
   17708    1, /* a */
   17709    false,
   17710    nir_type_invalid,
   17711    NULL,
   17712 };
   17713 
   17714 #include "compiler/nir/nir_search_helpers.h"
   17715 static const nir_search_variable replace249_1_0 = {
   17716    { nir_search_value_variable, 0 },
   17717    0, /* d */
   17718    false,
   17719    nir_type_invalid,
   17720    NULL,
   17721 };
   17722 
   17723 #include "compiler/nir/nir_search_helpers.h"
   17724 static const nir_search_variable replace249_1_1 = {
   17725    { nir_search_value_variable, 0 },
   17726    2, /* b */
   17727    false,
   17728    nir_type_invalid,
   17729    NULL,
   17730 };
   17731 #include "compiler/nir/nir_search_helpers.h"
   17732 static const nir_search_expression replace249_1 = {
   17733    { nir_search_value_expression, 0 },
   17734    false,
   17735    nir_op_fne,
   17736    { &replace249_1_0.value, &replace249_1_1.value },
   17737    NULL,
   17738 };
   17739 
   17740 #include "compiler/nir/nir_search_helpers.h"
   17741 static const nir_search_variable replace249_2_0 = {
   17742    { nir_search_value_variable, 0 },
   17743    0, /* d */
   17744    false,
   17745    nir_type_invalid,
   17746    NULL,
   17747 };
   17748 
   17749 #include "compiler/nir/nir_search_helpers.h"
   17750 static const nir_search_variable replace249_2_1 = {
   17751    { nir_search_value_variable, 0 },
   17752    3, /* c */
   17753    false,
   17754    nir_type_invalid,
   17755    NULL,
   17756 };
   17757 #include "compiler/nir/nir_search_helpers.h"
   17758 static const nir_search_expression replace249_2 = {
   17759    { nir_search_value_expression, 0 },
   17760    false,
   17761    nir_op_fne,
   17762    { &replace249_2_0.value, &replace249_2_1.value },
   17763    NULL,
   17764 };
   17765 #include "compiler/nir/nir_search_helpers.h"
   17766 static const nir_search_expression replace249 = {
   17767    { nir_search_value_expression, 0 },
   17768    false,
   17769    nir_op_bcsel,
   17770    { &replace249_0.value, &replace249_1.value, &replace249_2.value },
   17771    NULL,
   17772 };
   17773 
   17774 static const struct transform nir_opt_algebraic_fne_xforms[] = {
   17775    { &search106, &replace106.value, 0 },
   17776    { &search248, &replace248.value, 0 },
   17777    { &search249, &replace249.value, 0 },
   17778 };
   17779 
   17780 #include "compiler/nir/nir_search_helpers.h"
   17781 static const nir_search_variable search15_0_0 = {
   17782    { nir_search_value_variable, 0 },
   17783    0, /* a */
   17784    false,
   17785    nir_type_invalid,
   17786    NULL,
   17787 };
   17788 #include "compiler/nir/nir_search_helpers.h"
   17789 static const nir_search_expression search15_0 = {
   17790    { nir_search_value_expression, 0 },
   17791    false,
   17792    nir_op_iabs,
   17793    { &search15_0_0.value },
   17794    NULL,
   17795 };
   17796 #include "compiler/nir/nir_search_helpers.h"
   17797 static const nir_search_expression search15 = {
   17798    { nir_search_value_expression, 0 },
   17799    false,
   17800    nir_op_iabs,
   17801    { &search15_0.value },
   17802    NULL,
   17803 };
   17804 
   17805 #include "compiler/nir/nir_search_helpers.h"
   17806 static const nir_search_variable replace15_0 = {
   17807    { nir_search_value_variable, 0 },
   17808    0, /* a */
   17809    false,
   17810    nir_type_invalid,
   17811    NULL,
   17812 };
   17813 #include "compiler/nir/nir_search_helpers.h"
   17814 static const nir_search_expression replace15 = {
   17815    { nir_search_value_expression, 0 },
   17816    false,
   17817    nir_op_iabs,
   17818    { &replace15_0.value },
   17819    NULL,
   17820 };
   17821 
   17822 #include "compiler/nir/nir_search_helpers.h"
   17823 static const nir_search_variable search16_0_0 = {
   17824    { nir_search_value_variable, 0 },
   17825    0, /* a */
   17826    false,
   17827    nir_type_invalid,
   17828    NULL,
   17829 };
   17830 #include "compiler/nir/nir_search_helpers.h"
   17831 static const nir_search_expression search16_0 = {
   17832    { nir_search_value_expression, 0 },
   17833    false,
   17834    nir_op_ineg,
   17835    { &search16_0_0.value },
   17836    NULL,
   17837 };
   17838 #include "compiler/nir/nir_search_helpers.h"
   17839 static const nir_search_expression search16 = {
   17840    { nir_search_value_expression, 0 },
   17841    false,
   17842    nir_op_iabs,
   17843    { &search16_0.value },
   17844    NULL,
   17845 };
   17846 
   17847 #include "compiler/nir/nir_search_helpers.h"
   17848 static const nir_search_variable replace16_0 = {
   17849    { nir_search_value_variable, 0 },
   17850    0, /* a */
   17851    false,
   17852    nir_type_invalid,
   17853    NULL,
   17854 };
   17855 #include "compiler/nir/nir_search_helpers.h"
   17856 static const nir_search_expression replace16 = {
   17857    { nir_search_value_expression, 0 },
   17858    false,
   17859    nir_op_iabs,
   17860    { &replace16_0.value },
   17861    NULL,
   17862 };
   17863 
   17864 #include "compiler/nir/nir_search_helpers.h"
   17865 static const nir_search_variable search188_0_0 = {
   17866    { nir_search_value_variable, 0 },
   17867    0, /* a */
   17868    false,
   17869    nir_type_invalid,
   17870    NULL,
   17871 };
   17872 #include "compiler/nir/nir_search_helpers.h"
   17873 static const nir_search_expression search188_0 = {
   17874    { nir_search_value_expression, 0 },
   17875    false,
   17876    nir_op_b2i,
   17877    { &search188_0_0.value },
   17878    NULL,
   17879 };
   17880 #include "compiler/nir/nir_search_helpers.h"
   17881 static const nir_search_expression search188 = {
   17882    { nir_search_value_expression, 0 },
   17883    false,
   17884    nir_op_iabs,
   17885    { &search188_0.value },
   17886    NULL,
   17887 };
   17888 
   17889 #include "compiler/nir/nir_search_helpers.h"
   17890 static const nir_search_variable replace188_0 = {
   17891    { nir_search_value_variable, 0 },
   17892    0, /* a */
   17893    false,
   17894    nir_type_invalid,
   17895    NULL,
   17896 };
   17897 #include "compiler/nir/nir_search_helpers.h"
   17898 static const nir_search_expression replace188 = {
   17899    { nir_search_value_expression, 0 },
   17900    false,
   17901    nir_op_b2i,
   17902    { &replace188_0.value },
   17903    NULL,
   17904 };
   17905 
   17906 #include "compiler/nir/nir_search_helpers.h"
   17907 static const nir_search_constant search206_0_0 = {
   17908    { nir_search_value_constant, 0 },
   17909    nir_type_int, { 0x0 /* 0 */ },
   17910 };
   17911 
   17912 #include "compiler/nir/nir_search_helpers.h"
   17913 static const nir_search_variable search206_0_1 = {
   17914    { nir_search_value_variable, 0 },
   17915    0, /* a */
   17916    false,
   17917    nir_type_invalid,
   17918    NULL,
   17919 };
   17920 #include "compiler/nir/nir_search_helpers.h"
   17921 static const nir_search_expression search206_0 = {
   17922    { nir_search_value_expression, 0 },
   17923    false,
   17924    nir_op_isub,
   17925    { &search206_0_0.value, &search206_0_1.value },
   17926    NULL,
   17927 };
   17928 #include "compiler/nir/nir_search_helpers.h"
   17929 static const nir_search_expression search206 = {
   17930    { nir_search_value_expression, 0 },
   17931    false,
   17932    nir_op_iabs,
   17933    { &search206_0.value },
   17934    NULL,
   17935 };
   17936 
   17937 #include "compiler/nir/nir_search_helpers.h"
   17938 static const nir_search_variable replace206_0 = {
   17939    { nir_search_value_variable, 0 },
   17940    0, /* a */
   17941    false,
   17942    nir_type_invalid,
   17943    NULL,
   17944 };
   17945 #include "compiler/nir/nir_search_helpers.h"
   17946 static const nir_search_expression replace206 = {
   17947    { nir_search_value_expression, 0 },
   17948    false,
   17949    nir_op_iabs,
   17950    { &replace206_0.value },
   17951    NULL,
   17952 };
   17953 
   17954 static const struct transform nir_opt_algebraic_iabs_xforms[] = {
   17955    { &search15, &replace15.value, 0 },
   17956    { &search16, &replace16.value, 0 },
   17957    { &search188, &replace188.value, 0 },
   17958    { &search206, &replace206.value, 0 },
   17959 };
   17960 
   17961 #include "compiler/nir/nir_search_helpers.h"
   17962 static const nir_search_variable search230_0 = {
   17963    { nir_search_value_variable, 0 },
   17964    0, /* v */
   17965    false,
   17966    nir_type_invalid,
   17967    NULL,
   17968 };
   17969 #include "compiler/nir/nir_search_helpers.h"
   17970 static const nir_search_expression search230 = {
   17971    { nir_search_value_expression, 0 },
   17972    false,
   17973    nir_op_unpack_unorm_4x8,
   17974    { &search230_0.value },
   17975    NULL,
   17976 };
   17977 
   17978 #include "compiler/nir/nir_search_helpers.h"
   17979 static const nir_search_variable replace230_0_0_0_0 = {
   17980    { nir_search_value_variable, 0 },
   17981    0, /* v */
   17982    false,
   17983    nir_type_invalid,
   17984    NULL,
   17985 };
   17986 
   17987 #include "compiler/nir/nir_search_helpers.h"
   17988 static const nir_search_constant replace230_0_0_0_1 = {
   17989    { nir_search_value_constant, 0 },
   17990    nir_type_int, { 0x0 /* 0 */ },
   17991 };
   17992 #include "compiler/nir/nir_search_helpers.h"
   17993 static const nir_search_expression replace230_0_0_0 = {
   17994    { nir_search_value_expression, 0 },
   17995    false,
   17996    nir_op_extract_u8,
   17997    { &replace230_0_0_0_0.value, &replace230_0_0_0_1.value },
   17998    NULL,
   17999 };
   18000 
   18001 #include "compiler/nir/nir_search_helpers.h"
   18002 static const nir_search_variable replace230_0_0_1_0 = {
   18003    { nir_search_value_variable, 0 },
   18004    0, /* v */
   18005    false,
   18006    nir_type_invalid,
   18007    NULL,
   18008 };
   18009 
   18010 #include "compiler/nir/nir_search_helpers.h"
   18011 static const nir_search_constant replace230_0_0_1_1 = {
   18012    { nir_search_value_constant, 0 },
   18013    nir_type_int, { 0x1 /* 1 */ },
   18014 };
   18015 #include "compiler/nir/nir_search_helpers.h"
   18016 static const nir_search_expression replace230_0_0_1 = {
   18017    { nir_search_value_expression, 0 },
   18018    false,
   18019    nir_op_extract_u8,
   18020    { &replace230_0_0_1_0.value, &replace230_0_0_1_1.value },
   18021    NULL,
   18022 };
   18023 
   18024 #include "compiler/nir/nir_search_helpers.h"
   18025 static const nir_search_variable replace230_0_0_2_0 = {
   18026    { nir_search_value_variable, 0 },
   18027    0, /* v */
   18028    false,
   18029    nir_type_invalid,
   18030    NULL,
   18031 };
   18032 
   18033 #include "compiler/nir/nir_search_helpers.h"
   18034 static const nir_search_constant replace230_0_0_2_1 = {
   18035    { nir_search_value_constant, 0 },
   18036    nir_type_int, { 0x2 /* 2 */ },
   18037 };
   18038 #include "compiler/nir/nir_search_helpers.h"
   18039 static const nir_search_expression replace230_0_0_2 = {
   18040    { nir_search_value_expression, 0 },
   18041    false,
   18042    nir_op_extract_u8,
   18043    { &replace230_0_0_2_0.value, &replace230_0_0_2_1.value },
   18044    NULL,
   18045 };
   18046 
   18047 #include "compiler/nir/nir_search_helpers.h"
   18048 static const nir_search_variable replace230_0_0_3_0 = {
   18049    { nir_search_value_variable, 0 },
   18050    0, /* v */
   18051    false,
   18052    nir_type_invalid,
   18053    NULL,
   18054 };
   18055 
   18056 #include "compiler/nir/nir_search_helpers.h"
   18057 static const nir_search_constant replace230_0_0_3_1 = {
   18058    { nir_search_value_constant, 0 },
   18059    nir_type_int, { 0x3 /* 3 */ },
   18060 };
   18061 #include "compiler/nir/nir_search_helpers.h"
   18062 static const nir_search_expression replace230_0_0_3 = {
   18063    { nir_search_value_expression, 0 },
   18064    false,
   18065    nir_op_extract_u8,
   18066    { &replace230_0_0_3_0.value, &replace230_0_0_3_1.value },
   18067    NULL,
   18068 };
   18069 #include "compiler/nir/nir_search_helpers.h"
   18070 static const nir_search_expression replace230_0_0 = {
   18071    { nir_search_value_expression, 0 },
   18072    false,
   18073    nir_op_vec4,
   18074    { &replace230_0_0_0.value, &replace230_0_0_1.value, &replace230_0_0_2.value, &replace230_0_0_3.value },
   18075    NULL,
   18076 };
   18077 #include "compiler/nir/nir_search_helpers.h"
   18078 static const nir_search_expression replace230_0 = {
   18079    { nir_search_value_expression, 0 },
   18080    false,
   18081    nir_op_u2f,
   18082    { &replace230_0_0.value },
   18083    NULL,
   18084 };
   18085 
   18086 #include "compiler/nir/nir_search_helpers.h"
   18087 static const nir_search_constant replace230_1 = {
   18088    { nir_search_value_constant, 0 },
   18089    nir_type_float, { 0x406fe00000000000 /* 255.0 */ },
   18090 };
   18091 #include "compiler/nir/nir_search_helpers.h"
   18092 static const nir_search_expression replace230 = {
   18093    { nir_search_value_expression, 0 },
   18094    false,
   18095    nir_op_fdiv,
   18096    { &replace230_0.value, &replace230_1.value },
   18097    NULL,
   18098 };
   18099 
   18100 static const struct transform nir_opt_algebraic_unpack_unorm_4x8_xforms[] = {
   18101    { &search230, &replace230.value, 34 },
   18102 };
   18103 
   18104 #include "compiler/nir/nir_search_helpers.h"
   18105 static const nir_search_variable search78_0 = {
   18106    { nir_search_value_variable, 0 },
   18107    0, /* a */
   18108    false,
   18109    nir_type_invalid,
   18110    NULL,
   18111 };
   18112 
   18113 #include "compiler/nir/nir_search_helpers.h"
   18114 static const nir_search_variable search78_1 = {
   18115    { nir_search_value_variable, 0 },
   18116    0, /* a */
   18117    false,
   18118    nir_type_invalid,
   18119    NULL,
   18120 };
   18121 #include "compiler/nir/nir_search_helpers.h"
   18122 static const nir_search_expression search78 = {
   18123    { nir_search_value_expression, 0 },
   18124    false,
   18125    nir_op_fmin,
   18126    { &search78_0.value, &search78_1.value },
   18127    NULL,
   18128 };
   18129 
   18130 #include "compiler/nir/nir_search_helpers.h"
   18131 static const nir_search_variable replace78 = {
   18132    { nir_search_value_variable, 0 },
   18133    0, /* a */
   18134    false,
   18135    nir_type_invalid,
   18136    NULL,
   18137 };
   18138 
   18139 #include "compiler/nir/nir_search_helpers.h"
   18140 static const nir_search_variable search84_0_0 = {
   18141    { nir_search_value_variable, 0 },
   18142    0, /* a */
   18143    false,
   18144    nir_type_invalid,
   18145    NULL,
   18146 };
   18147 
   18148 #include "compiler/nir/nir_search_helpers.h"
   18149 static const nir_search_constant search84_0_1 = {
   18150    { nir_search_value_constant, 0 },
   18151    nir_type_float, { 0x0 /* 0.0 */ },
   18152 };
   18153 #include "compiler/nir/nir_search_helpers.h"
   18154 static const nir_search_expression search84_0 = {
   18155    { nir_search_value_expression, 0 },
   18156    false,
   18157    nir_op_fmax,
   18158    { &search84_0_0.value, &search84_0_1.value },
   18159    NULL,
   18160 };
   18161 
   18162 #include "compiler/nir/nir_search_helpers.h"
   18163 static const nir_search_constant search84_1 = {
   18164    { nir_search_value_constant, 0 },
   18165    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   18166 };
   18167 #include "compiler/nir/nir_search_helpers.h"
   18168 static const nir_search_expression search84 = {
   18169    { nir_search_value_expression, 0 },
   18170    true,
   18171    nir_op_fmin,
   18172    { &search84_0.value, &search84_1.value },
   18173    NULL,
   18174 };
   18175 
   18176 #include "compiler/nir/nir_search_helpers.h"
   18177 static const nir_search_variable replace84_0 = {
   18178    { nir_search_value_variable, 0 },
   18179    0, /* a */
   18180    false,
   18181    nir_type_invalid,
   18182    NULL,
   18183 };
   18184 #include "compiler/nir/nir_search_helpers.h"
   18185 static const nir_search_expression replace84 = {
   18186    { nir_search_value_expression, 0 },
   18187    false,
   18188    nir_op_fsat,
   18189    { &replace84_0.value },
   18190    NULL,
   18191 };
   18192 
   18193 #include "compiler/nir/nir_search_helpers.h"
   18194 static const nir_search_variable search88_0_0_0_0 = {
   18195    { nir_search_value_variable, 0 },
   18196    0, /* a */
   18197    false,
   18198    nir_type_invalid,
   18199    NULL,
   18200 };
   18201 
   18202 #include "compiler/nir/nir_search_helpers.h"
   18203 static const nir_search_variable search88_0_0_0_1 = {
   18204    { nir_search_value_variable, 0 },
   18205    1, /* b */
   18206    false,
   18207    nir_type_invalid,
   18208    NULL,
   18209 };
   18210 #include "compiler/nir/nir_search_helpers.h"
   18211 static const nir_search_expression search88_0_0_0 = {
   18212    { nir_search_value_expression, 0 },
   18213    false,
   18214    nir_op_fmax,
   18215    { &search88_0_0_0_0.value, &search88_0_0_0_1.value },
   18216    NULL,
   18217 };
   18218 
   18219 #include "compiler/nir/nir_search_helpers.h"
   18220 static const nir_search_variable search88_0_0_1 = {
   18221    { nir_search_value_variable, 0 },
   18222    2, /* c */
   18223    false,
   18224    nir_type_invalid,
   18225    NULL,
   18226 };
   18227 #include "compiler/nir/nir_search_helpers.h"
   18228 static const nir_search_expression search88_0_0 = {
   18229    { nir_search_value_expression, 0 },
   18230    false,
   18231    nir_op_fmin,
   18232    { &search88_0_0_0.value, &search88_0_0_1.value },
   18233    NULL,
   18234 };
   18235 
   18236 #include "compiler/nir/nir_search_helpers.h"
   18237 static const nir_search_variable search88_0_1 = {
   18238    { nir_search_value_variable, 0 },
   18239    1, /* b */
   18240    false,
   18241    nir_type_invalid,
   18242    NULL,
   18243 };
   18244 #include "compiler/nir/nir_search_helpers.h"
   18245 static const nir_search_expression search88_0 = {
   18246    { nir_search_value_expression, 0 },
   18247    false,
   18248    nir_op_fmax,
   18249    { &search88_0_0.value, &search88_0_1.value },
   18250    NULL,
   18251 };
   18252 
   18253 #include "compiler/nir/nir_search_helpers.h"
   18254 static const nir_search_variable search88_1 = {
   18255    { nir_search_value_variable, 0 },
   18256    2, /* c */
   18257    false,
   18258    nir_type_invalid,
   18259    NULL,
   18260 };
   18261 #include "compiler/nir/nir_search_helpers.h"
   18262 static const nir_search_expression search88 = {
   18263    { nir_search_value_expression, 0 },
   18264    false,
   18265    nir_op_fmin,
   18266    { &search88_0.value, &search88_1.value },
   18267    NULL,
   18268 };
   18269 
   18270 #include "compiler/nir/nir_search_helpers.h"
   18271 static const nir_search_variable replace88_0_0 = {
   18272    { nir_search_value_variable, 0 },
   18273    0, /* a */
   18274    false,
   18275    nir_type_invalid,
   18276    NULL,
   18277 };
   18278 
   18279 #include "compiler/nir/nir_search_helpers.h"
   18280 static const nir_search_variable replace88_0_1 = {
   18281    { nir_search_value_variable, 0 },
   18282    1, /* b */
   18283    false,
   18284    nir_type_invalid,
   18285    NULL,
   18286 };
   18287 #include "compiler/nir/nir_search_helpers.h"
   18288 static const nir_search_expression replace88_0 = {
   18289    { nir_search_value_expression, 0 },
   18290    false,
   18291    nir_op_fmax,
   18292    { &replace88_0_0.value, &replace88_0_1.value },
   18293    NULL,
   18294 };
   18295 
   18296 #include "compiler/nir/nir_search_helpers.h"
   18297 static const nir_search_variable replace88_1 = {
   18298    { nir_search_value_variable, 0 },
   18299    2, /* c */
   18300    false,
   18301    nir_type_invalid,
   18302    NULL,
   18303 };
   18304 #include "compiler/nir/nir_search_helpers.h"
   18305 static const nir_search_expression replace88 = {
   18306    { nir_search_value_expression, 0 },
   18307    false,
   18308    nir_op_fmin,
   18309    { &replace88_0.value, &replace88_1.value },
   18310    NULL,
   18311 };
   18312 
   18313 #include "compiler/nir/nir_search_helpers.h"
   18314 static const nir_search_variable search92_0_0 = {
   18315    { nir_search_value_variable, 0 },
   18316    0, /* a */
   18317    false,
   18318    nir_type_invalid,
   18319    NULL,
   18320 };
   18321 #include "compiler/nir/nir_search_helpers.h"
   18322 static const nir_search_expression search92_0 = {
   18323    { nir_search_value_expression, 0 },
   18324    false,
   18325    nir_op_fsat,
   18326    { &search92_0_0.value },
   18327    NULL,
   18328 };
   18329 
   18330 #include "compiler/nir/nir_search_helpers.h"
   18331 static const nir_search_variable search92_1 = {
   18332    { nir_search_value_variable, 32 },
   18333    1, /* b */
   18334    true,
   18335    nir_type_invalid,
   18336    (is_zero_to_one),
   18337 };
   18338 #include "compiler/nir/nir_search_helpers.h"
   18339 static const nir_search_expression search92 = {
   18340    { nir_search_value_expression, 0 },
   18341    false,
   18342    nir_op_fmin,
   18343    { &search92_0.value, &search92_1.value },
   18344    NULL,
   18345 };
   18346 
   18347 #include "compiler/nir/nir_search_helpers.h"
   18348 static const nir_search_variable replace92_0_0 = {
   18349    { nir_search_value_variable, 0 },
   18350    0, /* a */
   18351    false,
   18352    nir_type_invalid,
   18353    NULL,
   18354 };
   18355 
   18356 #include "compiler/nir/nir_search_helpers.h"
   18357 static const nir_search_variable replace92_0_1 = {
   18358    { nir_search_value_variable, 0 },
   18359    1, /* b */
   18360    false,
   18361    nir_type_invalid,
   18362    NULL,
   18363 };
   18364 #include "compiler/nir/nir_search_helpers.h"
   18365 static const nir_search_expression replace92_0 = {
   18366    { nir_search_value_expression, 0 },
   18367    false,
   18368    nir_op_fmin,
   18369    { &replace92_0_0.value, &replace92_0_1.value },
   18370    NULL,
   18371 };
   18372 #include "compiler/nir/nir_search_helpers.h"
   18373 static const nir_search_expression replace92 = {
   18374    { nir_search_value_expression, 0 },
   18375    false,
   18376    nir_op_fsat,
   18377    { &replace92_0.value },
   18378    NULL,
   18379 };
   18380 
   18381 static const struct transform nir_opt_algebraic_fmin_xforms[] = {
   18382    { &search78, &replace78.value, 0 },
   18383    { &search84, &replace84.value, 9 },
   18384    { &search88, &replace88.value, 0 },
   18385    { &search92, &replace92.value, 0 },
   18386 };
   18387 
   18388 #include "compiler/nir/nir_search_helpers.h"
   18389 static const nir_search_variable search118_0 = {
   18390    { nir_search_value_variable, 0 },
   18391    0, /* a */
   18392    false,
   18393    nir_type_invalid,
   18394    NULL,
   18395 };
   18396 
   18397 #include "compiler/nir/nir_search_helpers.h"
   18398 static const nir_search_variable search118_1 = {
   18399    { nir_search_value_variable, 0 },
   18400    0, /* a */
   18401    false,
   18402    nir_type_invalid,
   18403    NULL,
   18404 };
   18405 #include "compiler/nir/nir_search_helpers.h"
   18406 static const nir_search_expression search118 = {
   18407    { nir_search_value_expression, 0 },
   18408    false,
   18409    nir_op_ine,
   18410    { &search118_0.value, &search118_1.value },
   18411    NULL,
   18412 };
   18413 
   18414 #include "compiler/nir/nir_search_helpers.h"
   18415 static const nir_search_constant replace118 = {
   18416    { nir_search_value_constant, 32 },
   18417    nir_type_bool32, { NIR_FALSE /* False */ },
   18418 };
   18419 
   18420 #include "compiler/nir/nir_search_helpers.h"
   18421 static const nir_search_variable search168_0 = {
   18422    { nir_search_value_variable, 32 },
   18423    0, /* a */
   18424    false,
   18425    nir_type_bool32,
   18426    NULL,
   18427 };
   18428 
   18429 #include "compiler/nir/nir_search_helpers.h"
   18430 static const nir_search_constant search168_1 = {
   18431    { nir_search_value_constant, 32 },
   18432    nir_type_bool32, { NIR_TRUE /* True */ },
   18433 };
   18434 #include "compiler/nir/nir_search_helpers.h"
   18435 static const nir_search_expression search168 = {
   18436    { nir_search_value_expression, 0 },
   18437    false,
   18438    nir_op_ine,
   18439    { &search168_0.value, &search168_1.value },
   18440    (is_not_used_by_if),
   18441 };
   18442 
   18443 #include "compiler/nir/nir_search_helpers.h"
   18444 static const nir_search_variable replace168_0 = {
   18445    { nir_search_value_variable, 0 },
   18446    0, /* a */
   18447    false,
   18448    nir_type_invalid,
   18449    NULL,
   18450 };
   18451 #include "compiler/nir/nir_search_helpers.h"
   18452 static const nir_search_expression replace168 = {
   18453    { nir_search_value_expression, 0 },
   18454    false,
   18455    nir_op_inot,
   18456    { &replace168_0.value },
   18457    NULL,
   18458 };
   18459 
   18460 #include "compiler/nir/nir_search_helpers.h"
   18461 static const nir_search_variable search169_0 = {
   18462    { nir_search_value_variable, 32 },
   18463    0, /* a */
   18464    false,
   18465    nir_type_bool32,
   18466    NULL,
   18467 };
   18468 
   18469 #include "compiler/nir/nir_search_helpers.h"
   18470 static const nir_search_constant search169_1 = {
   18471    { nir_search_value_constant, 32 },
   18472    nir_type_bool32, { NIR_FALSE /* False */ },
   18473 };
   18474 #include "compiler/nir/nir_search_helpers.h"
   18475 static const nir_search_expression search169 = {
   18476    { nir_search_value_expression, 0 },
   18477    false,
   18478    nir_op_ine,
   18479    { &search169_0.value, &search169_1.value },
   18480    NULL,
   18481 };
   18482 
   18483 #include "compiler/nir/nir_search_helpers.h"
   18484 static const nir_search_variable replace169 = {
   18485    { nir_search_value_variable, 0 },
   18486    0, /* a */
   18487    false,
   18488    nir_type_invalid,
   18489    NULL,
   18490 };
   18491 
   18492 #include "compiler/nir/nir_search_helpers.h"
   18493 static const nir_search_variable search256_0_0 = {
   18494    { nir_search_value_variable, 0 },
   18495    0, /* a */
   18496    false,
   18497    nir_type_invalid,
   18498    NULL,
   18499 };
   18500 
   18501 #include "compiler/nir/nir_search_helpers.h"
   18502 static const nir_search_variable search256_0_1 = {
   18503    { nir_search_value_variable, 0 },
   18504    1, /* b */
   18505    true,
   18506    nir_type_invalid,
   18507    NULL,
   18508 };
   18509 
   18510 #include "compiler/nir/nir_search_helpers.h"
   18511 static const nir_search_variable search256_0_2 = {
   18512    { nir_search_value_variable, 0 },
   18513    2, /* c */
   18514    true,
   18515    nir_type_invalid,
   18516    NULL,
   18517 };
   18518 #include "compiler/nir/nir_search_helpers.h"
   18519 static const nir_search_expression search256_0 = {
   18520    { nir_search_value_expression, 0 },
   18521    false,
   18522    nir_op_bcsel,
   18523    { &search256_0_0.value, &search256_0_1.value, &search256_0_2.value },
   18524    NULL,
   18525 };
   18526 
   18527 #include "compiler/nir/nir_search_helpers.h"
   18528 static const nir_search_variable search256_1 = {
   18529    { nir_search_value_variable, 0 },
   18530    3, /* d */
   18531    true,
   18532    nir_type_invalid,
   18533    NULL,
   18534 };
   18535 #include "compiler/nir/nir_search_helpers.h"
   18536 static const nir_search_expression search256 = {
   18537    { nir_search_value_expression, 0 },
   18538    false,
   18539    nir_op_ine,
   18540    { &search256_0.value, &search256_1.value },
   18541    NULL,
   18542 };
   18543 
   18544 #include "compiler/nir/nir_search_helpers.h"
   18545 static const nir_search_variable replace256_0 = {
   18546    { nir_search_value_variable, 0 },
   18547    0, /* a */
   18548    false,
   18549    nir_type_invalid,
   18550    NULL,
   18551 };
   18552 
   18553 #include "compiler/nir/nir_search_helpers.h"
   18554 static const nir_search_variable replace256_1_0 = {
   18555    { nir_search_value_variable, 0 },
   18556    1, /* b */
   18557    false,
   18558    nir_type_invalid,
   18559    NULL,
   18560 };
   18561 
   18562 #include "compiler/nir/nir_search_helpers.h"
   18563 static const nir_search_variable replace256_1_1 = {
   18564    { nir_search_value_variable, 0 },
   18565    3, /* d */
   18566    false,
   18567    nir_type_invalid,
   18568    NULL,
   18569 };
   18570 #include "compiler/nir/nir_search_helpers.h"
   18571 static const nir_search_expression replace256_1 = {
   18572    { nir_search_value_expression, 0 },
   18573    false,
   18574    nir_op_ine,
   18575    { &replace256_1_0.value, &replace256_1_1.value },
   18576    NULL,
   18577 };
   18578 
   18579 #include "compiler/nir/nir_search_helpers.h"
   18580 static const nir_search_variable replace256_2_0 = {
   18581    { nir_search_value_variable, 0 },
   18582    2, /* c */
   18583    false,
   18584    nir_type_invalid,
   18585    NULL,
   18586 };
   18587 
   18588 #include "compiler/nir/nir_search_helpers.h"
   18589 static const nir_search_variable replace256_2_1 = {
   18590    { nir_search_value_variable, 0 },
   18591    3, /* d */
   18592    false,
   18593    nir_type_invalid,
   18594    NULL,
   18595 };
   18596 #include "compiler/nir/nir_search_helpers.h"
   18597 static const nir_search_expression replace256_2 = {
   18598    { nir_search_value_expression, 0 },
   18599    false,
   18600    nir_op_ine,
   18601    { &replace256_2_0.value, &replace256_2_1.value },
   18602    NULL,
   18603 };
   18604 #include "compiler/nir/nir_search_helpers.h"
   18605 static const nir_search_expression replace256 = {
   18606    { nir_search_value_expression, 0 },
   18607    false,
   18608    nir_op_bcsel,
   18609    { &replace256_0.value, &replace256_1.value, &replace256_2.value },
   18610    NULL,
   18611 };
   18612 
   18613 #include "compiler/nir/nir_search_helpers.h"
   18614 static const nir_search_variable search257_0 = {
   18615    { nir_search_value_variable, 0 },
   18616    0, /* d */
   18617    true,
   18618    nir_type_invalid,
   18619    NULL,
   18620 };
   18621 
   18622 #include "compiler/nir/nir_search_helpers.h"
   18623 static const nir_search_variable search257_1_0 = {
   18624    { nir_search_value_variable, 0 },
   18625    1, /* a */
   18626    false,
   18627    nir_type_invalid,
   18628    NULL,
   18629 };
   18630 
   18631 #include "compiler/nir/nir_search_helpers.h"
   18632 static const nir_search_variable search257_1_1 = {
   18633    { nir_search_value_variable, 0 },
   18634    2, /* b */
   18635    true,
   18636    nir_type_invalid,
   18637    NULL,
   18638 };
   18639 
   18640 #include "compiler/nir/nir_search_helpers.h"
   18641 static const nir_search_variable search257_1_2 = {
   18642    { nir_search_value_variable, 0 },
   18643    3, /* c */
   18644    true,
   18645    nir_type_invalid,
   18646    NULL,
   18647 };
   18648 #include "compiler/nir/nir_search_helpers.h"
   18649 static const nir_search_expression search257_1 = {
   18650    { nir_search_value_expression, 0 },
   18651    false,
   18652    nir_op_bcsel,
   18653    { &search257_1_0.value, &search257_1_1.value, &search257_1_2.value },
   18654    NULL,
   18655 };
   18656 #include "compiler/nir/nir_search_helpers.h"
   18657 static const nir_search_expression search257 = {
   18658    { nir_search_value_expression, 0 },
   18659    false,
   18660    nir_op_ine,
   18661    { &search257_0.value, &search257_1.value },
   18662    NULL,
   18663 };
   18664 
   18665 #include "compiler/nir/nir_search_helpers.h"
   18666 static const nir_search_variable replace257_0 = {
   18667    { nir_search_value_variable, 0 },
   18668    1, /* a */
   18669    false,
   18670    nir_type_invalid,
   18671    NULL,
   18672 };
   18673 
   18674 #include "compiler/nir/nir_search_helpers.h"
   18675 static const nir_search_variable replace257_1_0 = {
   18676    { nir_search_value_variable, 0 },
   18677    0, /* d */
   18678    false,
   18679    nir_type_invalid,
   18680    NULL,
   18681 };
   18682 
   18683 #include "compiler/nir/nir_search_helpers.h"
   18684 static const nir_search_variable replace257_1_1 = {
   18685    { nir_search_value_variable, 0 },
   18686    2, /* b */
   18687    false,
   18688    nir_type_invalid,
   18689    NULL,
   18690 };
   18691 #include "compiler/nir/nir_search_helpers.h"
   18692 static const nir_search_expression replace257_1 = {
   18693    { nir_search_value_expression, 0 },
   18694    false,
   18695    nir_op_ine,
   18696    { &replace257_1_0.value, &replace257_1_1.value },
   18697    NULL,
   18698 };
   18699 
   18700 #include "compiler/nir/nir_search_helpers.h"
   18701 static const nir_search_variable replace257_2_0 = {
   18702    { nir_search_value_variable, 0 },
   18703    0, /* d */
   18704    false,
   18705    nir_type_invalid,
   18706    NULL,
   18707 };
   18708 
   18709 #include "compiler/nir/nir_search_helpers.h"
   18710 static const nir_search_variable replace257_2_1 = {
   18711    { nir_search_value_variable, 0 },
   18712    3, /* c */
   18713    false,
   18714    nir_type_invalid,
   18715    NULL,
   18716 };
   18717 #include "compiler/nir/nir_search_helpers.h"
   18718 static const nir_search_expression replace257_2 = {
   18719    { nir_search_value_expression, 0 },
   18720    false,
   18721    nir_op_ine,
   18722    { &replace257_2_0.value, &replace257_2_1.value },
   18723    NULL,
   18724 };
   18725 #include "compiler/nir/nir_search_helpers.h"
   18726 static const nir_search_expression replace257 = {
   18727    { nir_search_value_expression, 0 },
   18728    false,
   18729    nir_op_bcsel,
   18730    { &replace257_0.value, &replace257_1.value, &replace257_2.value },
   18731    NULL,
   18732 };
   18733 
   18734 static const struct transform nir_opt_algebraic_ine_xforms[] = {
   18735    { &search118, &replace118.value, 0 },
   18736    { &search168, &replace168.value, 0 },
   18737    { &search169, &replace169.value, 0 },
   18738    { &search256, &replace256.value, 0 },
   18739    { &search257, &replace257.value, 0 },
   18740 };
   18741 
   18742 #include "compiler/nir/nir_search_helpers.h"
   18743 static const nir_search_variable search2_0 = {
   18744    { nir_search_value_variable, 0 },
   18745    0, /* a */
   18746    false,
   18747    nir_type_invalid,
   18748    NULL,
   18749 };
   18750 
   18751 #include "compiler/nir/nir_search_helpers.h"
   18752 static const nir_search_constant search2_1 = {
   18753    { nir_search_value_constant, 0 },
   18754    nir_type_int, { 0x1 /* 1 */ },
   18755 };
   18756 #include "compiler/nir/nir_search_helpers.h"
   18757 static const nir_search_expression search2 = {
   18758    { nir_search_value_expression, 0 },
   18759    false,
   18760    nir_op_udiv,
   18761    { &search2_0.value, &search2_1.value },
   18762    NULL,
   18763 };
   18764 
   18765 #include "compiler/nir/nir_search_helpers.h"
   18766 static const nir_search_variable replace2 = {
   18767    { nir_search_value_variable, 0 },
   18768    0, /* a */
   18769    false,
   18770    nir_type_invalid,
   18771    NULL,
   18772 };
   18773 
   18774 #include "compiler/nir/nir_search_helpers.h"
   18775 static const nir_search_variable search6_0 = {
   18776    { nir_search_value_variable, 0 },
   18777    0, /* a */
   18778    false,
   18779    nir_type_invalid,
   18780    NULL,
   18781 };
   18782 
   18783 #include "compiler/nir/nir_search_helpers.h"
   18784 static const nir_search_variable search6_1 = {
   18785    { nir_search_value_variable, 32 },
   18786    1, /* b */
   18787    true,
   18788    nir_type_invalid,
   18789    (is_pos_power_of_two),
   18790 };
   18791 #include "compiler/nir/nir_search_helpers.h"
   18792 static const nir_search_expression search6 = {
   18793    { nir_search_value_expression, 0 },
   18794    false,
   18795    nir_op_udiv,
   18796    { &search6_0.value, &search6_1.value },
   18797    NULL,
   18798 };
   18799 
   18800 #include "compiler/nir/nir_search_helpers.h"
   18801 static const nir_search_variable replace6_0 = {
   18802    { nir_search_value_variable, 0 },
   18803    0, /* a */
   18804    false,
   18805    nir_type_invalid,
   18806    NULL,
   18807 };
   18808 
   18809 #include "compiler/nir/nir_search_helpers.h"
   18810 static const nir_search_variable replace6_1_0 = {
   18811    { nir_search_value_variable, 0 },
   18812    1, /* b */
   18813    false,
   18814    nir_type_invalid,
   18815    NULL,
   18816 };
   18817 #include "compiler/nir/nir_search_helpers.h"
   18818 static const nir_search_expression replace6_1 = {
   18819    { nir_search_value_expression, 0 },
   18820    false,
   18821    nir_op_find_lsb,
   18822    { &replace6_1_0.value },
   18823    NULL,
   18824 };
   18825 #include "compiler/nir/nir_search_helpers.h"
   18826 static const nir_search_expression replace6 = {
   18827    { nir_search_value_expression, 0 },
   18828    false,
   18829    nir_op_ushr,
   18830    { &replace6_0.value, &replace6_1.value },
   18831    NULL,
   18832 };
   18833 
   18834 static const struct transform nir_opt_algebraic_udiv_xforms[] = {
   18835    { &search2, &replace2.value, 0 },
   18836    { &search6, &replace6.value, 0 },
   18837 };
   18838 
   18839 #include "compiler/nir/nir_search_helpers.h"
   18840 static const nir_search_variable search221_0 = {
   18841    { nir_search_value_variable, 0 },
   18842    0, /* a */
   18843    false,
   18844    nir_type_invalid,
   18845    NULL,
   18846 };
   18847 
   18848 #include "compiler/nir/nir_search_helpers.h"
   18849 static const nir_search_variable search221_1 = {
   18850    { nir_search_value_variable, 0 },
   18851    1, /* b */
   18852    false,
   18853    nir_type_invalid,
   18854    NULL,
   18855 };
   18856 #include "compiler/nir/nir_search_helpers.h"
   18857 static const nir_search_expression search221 = {
   18858    { nir_search_value_expression, 0 },
   18859    false,
   18860    nir_op_extract_i8,
   18861    { &search221_0.value, &search221_1.value },
   18862    NULL,
   18863 };
   18864 
   18865 #include "compiler/nir/nir_search_helpers.h"
   18866 static const nir_search_variable replace221_0_0 = {
   18867    { nir_search_value_variable, 0 },
   18868    0, /* a */
   18869    false,
   18870    nir_type_invalid,
   18871    NULL,
   18872 };
   18873 
   18874 #include "compiler/nir/nir_search_helpers.h"
   18875 static const nir_search_constant replace221_0_1_0_0 = {
   18876    { nir_search_value_constant, 0 },
   18877    nir_type_int, { 0x3 /* 3 */ },
   18878 };
   18879 
   18880 #include "compiler/nir/nir_search_helpers.h"
   18881 static const nir_search_variable replace221_0_1_0_1 = {
   18882    { nir_search_value_variable, 0 },
   18883    1, /* b */
   18884    false,
   18885    nir_type_invalid,
   18886    NULL,
   18887 };
   18888 #include "compiler/nir/nir_search_helpers.h"
   18889 static const nir_search_expression replace221_0_1_0 = {
   18890    { nir_search_value_expression, 0 },
   18891    false,
   18892    nir_op_isub,
   18893    { &replace221_0_1_0_0.value, &replace221_0_1_0_1.value },
   18894    NULL,
   18895 };
   18896 
   18897 #include "compiler/nir/nir_search_helpers.h"
   18898 static const nir_search_constant replace221_0_1_1 = {
   18899    { nir_search_value_constant, 0 },
   18900    nir_type_int, { 0x8 /* 8 */ },
   18901 };
   18902 #include "compiler/nir/nir_search_helpers.h"
   18903 static const nir_search_expression replace221_0_1 = {
   18904    { nir_search_value_expression, 0 },
   18905    false,
   18906    nir_op_imul,
   18907    { &replace221_0_1_0.value, &replace221_0_1_1.value },
   18908    NULL,
   18909 };
   18910 #include "compiler/nir/nir_search_helpers.h"
   18911 static const nir_search_expression replace221_0 = {
   18912    { nir_search_value_expression, 0 },
   18913    false,
   18914    nir_op_ishl,
   18915    { &replace221_0_0.value, &replace221_0_1.value },
   18916    NULL,
   18917 };
   18918 
   18919 #include "compiler/nir/nir_search_helpers.h"
   18920 static const nir_search_constant replace221_1 = {
   18921    { nir_search_value_constant, 0 },
   18922    nir_type_int, { 0x18 /* 24 */ },
   18923 };
   18924 #include "compiler/nir/nir_search_helpers.h"
   18925 static const nir_search_expression replace221 = {
   18926    { nir_search_value_expression, 0 },
   18927    false,
   18928    nir_op_ishr,
   18929    { &replace221_0.value, &replace221_1.value },
   18930    NULL,
   18931 };
   18932 
   18933 static const struct transform nir_opt_algebraic_extract_i8_xforms[] = {
   18934    { &search221, &replace221.value, 27 },
   18935 };
   18936 
   18937 #include "compiler/nir/nir_search_helpers.h"
   18938 static const nir_search_variable search216_0 = {
   18939    { nir_search_value_variable, 0 },
   18940    0, /* a */
   18941    false,
   18942    nir_type_invalid,
   18943    NULL,
   18944 };
   18945 
   18946 #include "compiler/nir/nir_search_helpers.h"
   18947 static const nir_search_variable search216_1 = {
   18948    { nir_search_value_variable, 0 },
   18949    1, /* b */
   18950    false,
   18951    nir_type_invalid,
   18952    NULL,
   18953 };
   18954 #include "compiler/nir/nir_search_helpers.h"
   18955 static const nir_search_expression search216 = {
   18956    { nir_search_value_expression, 32 },
   18957    false,
   18958    nir_op_uadd_carry,
   18959    { &search216_0.value, &search216_1.value },
   18960    NULL,
   18961 };
   18962 
   18963 #include "compiler/nir/nir_search_helpers.h"
   18964 static const nir_search_variable replace216_0_0_0 = {
   18965    { nir_search_value_variable, 0 },
   18966    0, /* a */
   18967    false,
   18968    nir_type_invalid,
   18969    NULL,
   18970 };
   18971 
   18972 #include "compiler/nir/nir_search_helpers.h"
   18973 static const nir_search_variable replace216_0_0_1 = {
   18974    { nir_search_value_variable, 0 },
   18975    1, /* b */
   18976    false,
   18977    nir_type_invalid,
   18978    NULL,
   18979 };
   18980 #include "compiler/nir/nir_search_helpers.h"
   18981 static const nir_search_expression replace216_0_0 = {
   18982    { nir_search_value_expression, 0 },
   18983    false,
   18984    nir_op_iadd,
   18985    { &replace216_0_0_0.value, &replace216_0_0_1.value },
   18986    NULL,
   18987 };
   18988 
   18989 #include "compiler/nir/nir_search_helpers.h"
   18990 static const nir_search_variable replace216_0_1 = {
   18991    { nir_search_value_variable, 0 },
   18992    0, /* a */
   18993    false,
   18994    nir_type_invalid,
   18995    NULL,
   18996 };
   18997 #include "compiler/nir/nir_search_helpers.h"
   18998 static const nir_search_expression replace216_0 = {
   18999    { nir_search_value_expression, 0 },
   19000    false,
   19001    nir_op_ult,
   19002    { &replace216_0_0.value, &replace216_0_1.value },
   19003    NULL,
   19004 };
   19005 #include "compiler/nir/nir_search_helpers.h"
   19006 static const nir_search_expression replace216 = {
   19007    { nir_search_value_expression, 0 },
   19008    false,
   19009    nir_op_b2i,
   19010    { &replace216_0.value },
   19011    NULL,
   19012 };
   19013 
   19014 static const struct transform nir_opt_algebraic_uadd_carry_xforms[] = {
   19015    { &search216, &replace216.value, 23 },
   19016 };
   19017 
   19018 #include "compiler/nir/nir_search_helpers.h"
   19019 static const nir_search_variable search219_0 = {
   19020    { nir_search_value_variable, 0 },
   19021    0, /* value */
   19022    false,
   19023    nir_type_invalid,
   19024    NULL,
   19025 };
   19026 
   19027 #include "compiler/nir/nir_search_helpers.h"
   19028 static const nir_search_variable search219_1 = {
   19029    { nir_search_value_variable, 0 },
   19030    1, /* offset */
   19031    false,
   19032    nir_type_invalid,
   19033    NULL,
   19034 };
   19035 
   19036 #include "compiler/nir/nir_search_helpers.h"
   19037 static const nir_search_variable search219_2 = {
   19038    { nir_search_value_variable, 0 },
   19039    2, /* bits */
   19040    false,
   19041    nir_type_invalid,
   19042    NULL,
   19043 };
   19044 #include "compiler/nir/nir_search_helpers.h"
   19045 static const nir_search_expression search219 = {
   19046    { nir_search_value_expression, 0 },
   19047    false,
   19048    nir_op_ibitfield_extract,
   19049    { &search219_0.value, &search219_1.value, &search219_2.value },
   19050    NULL,
   19051 };
   19052 
   19053 #include "compiler/nir/nir_search_helpers.h"
   19054 static const nir_search_constant replace219_0_0 = {
   19055    { nir_search_value_constant, 0 },
   19056    nir_type_int, { 0x1f /* 31 */ },
   19057 };
   19058 
   19059 #include "compiler/nir/nir_search_helpers.h"
   19060 static const nir_search_variable replace219_0_1 = {
   19061    { nir_search_value_variable, 0 },
   19062    2, /* bits */
   19063    false,
   19064    nir_type_invalid,
   19065    NULL,
   19066 };
   19067 #include "compiler/nir/nir_search_helpers.h"
   19068 static const nir_search_expression replace219_0 = {
   19069    { nir_search_value_expression, 0 },
   19070    false,
   19071    nir_op_ilt,
   19072    { &replace219_0_0.value, &replace219_0_1.value },
   19073    NULL,
   19074 };
   19075 
   19076 #include "compiler/nir/nir_search_helpers.h"
   19077 static const nir_search_variable replace219_1 = {
   19078    { nir_search_value_variable, 0 },
   19079    0, /* value */
   19080    false,
   19081    nir_type_invalid,
   19082    NULL,
   19083 };
   19084 
   19085 #include "compiler/nir/nir_search_helpers.h"
   19086 static const nir_search_variable replace219_2_0 = {
   19087    { nir_search_value_variable, 0 },
   19088    0, /* value */
   19089    false,
   19090    nir_type_invalid,
   19091    NULL,
   19092 };
   19093 
   19094 #include "compiler/nir/nir_search_helpers.h"
   19095 static const nir_search_variable replace219_2_1 = {
   19096    { nir_search_value_variable, 0 },
   19097    1, /* offset */
   19098    false,
   19099    nir_type_invalid,
   19100    NULL,
   19101 };
   19102 
   19103 #include "compiler/nir/nir_search_helpers.h"
   19104 static const nir_search_variable replace219_2_2 = {
   19105    { nir_search_value_variable, 0 },
   19106    2, /* bits */
   19107    false,
   19108    nir_type_invalid,
   19109    NULL,
   19110 };
   19111 #include "compiler/nir/nir_search_helpers.h"
   19112 static const nir_search_expression replace219_2 = {
   19113    { nir_search_value_expression, 0 },
   19114    false,
   19115    nir_op_ibfe,
   19116    { &replace219_2_0.value, &replace219_2_1.value, &replace219_2_2.value },
   19117    NULL,
   19118 };
   19119 #include "compiler/nir/nir_search_helpers.h"
   19120 static const nir_search_expression replace219 = {
   19121    { nir_search_value_expression, 0 },
   19122    false,
   19123    nir_op_bcsel,
   19124    { &replace219_0.value, &replace219_1.value, &replace219_2.value },
   19125    NULL,
   19126 };
   19127 
   19128 static const struct transform nir_opt_algebraic_ibitfield_extract_xforms[] = {
   19129    { &search219, &replace219.value, 26 },
   19130 };
   19131 
   19132 #include "compiler/nir/nir_search_helpers.h"
   19133 static const nir_search_variable search233_0 = {
   19134    { nir_search_value_variable, 0 },
   19135    0, /* x */
   19136    false,
   19137    nir_type_invalid,
   19138    NULL,
   19139 };
   19140 
   19141 #include "compiler/nir/nir_search_helpers.h"
   19142 static const nir_search_variable search233_1 = {
   19143    { nir_search_value_variable, 0 },
   19144    1, /* exp */
   19145    false,
   19146    nir_type_invalid,
   19147    NULL,
   19148 };
   19149 #include "compiler/nir/nir_search_helpers.h"
   19150 static const nir_search_expression search233 = {
   19151    { nir_search_value_expression, 32 },
   19152    false,
   19153    nir_op_ldexp,
   19154    { &search233_0.value, &search233_1.value },
   19155    NULL,
   19156 };
   19157 
   19158 #include "compiler/nir/nir_search_helpers.h"
   19159 static const nir_search_variable replace233_0_0 = {
   19160    { nir_search_value_variable, 0 },
   19161    0, /* x */
   19162    false,
   19163    nir_type_invalid,
   19164    NULL,
   19165 };
   19166 
   19167 #include "compiler/nir/nir_search_helpers.h"
   19168 static const nir_search_variable replace233_0_1_0_0_0_0_0 = {
   19169    { nir_search_value_variable, 0 },
   19170    1, /* exp */
   19171    false,
   19172    nir_type_invalid,
   19173    NULL,
   19174 };
   19175 
   19176 #include "compiler/nir/nir_search_helpers.h"
   19177 static const nir_search_constant replace233_0_1_0_0_0_0_1 = {
   19178    { nir_search_value_constant, 0 },
   19179    nir_type_int, { -0xfc /* -252 */ },
   19180 };
   19181 #include "compiler/nir/nir_search_helpers.h"
   19182 static const nir_search_expression replace233_0_1_0_0_0_0 = {
   19183    { nir_search_value_expression, 0 },
   19184    false,
   19185    nir_op_imax,
   19186    { &replace233_0_1_0_0_0_0_0.value, &replace233_0_1_0_0_0_0_1.value },
   19187    NULL,
   19188 };
   19189 
   19190 #include "compiler/nir/nir_search_helpers.h"
   19191 static const nir_search_constant replace233_0_1_0_0_0_1 = {
   19192    { nir_search_value_constant, 0 },
   19193    nir_type_int, { 0xfe /* 254 */ },
   19194 };
   19195 #include "compiler/nir/nir_search_helpers.h"
   19196 static const nir_search_expression replace233_0_1_0_0_0 = {
   19197    { nir_search_value_expression, 0 },
   19198    false,
   19199    nir_op_imin,
   19200    { &replace233_0_1_0_0_0_0.value, &replace233_0_1_0_0_0_1.value },
   19201    NULL,
   19202 };
   19203 
   19204 #include "compiler/nir/nir_search_helpers.h"
   19205 static const nir_search_constant replace233_0_1_0_0_1 = {
   19206    { nir_search_value_constant, 0 },
   19207    nir_type_int, { 0x1 /* 1 */ },
   19208 };
   19209 #include "compiler/nir/nir_search_helpers.h"
   19210 static const nir_search_expression replace233_0_1_0_0 = {
   19211    { nir_search_value_expression, 0 },
   19212    false,
   19213    nir_op_ishr,
   19214    { &replace233_0_1_0_0_0.value, &replace233_0_1_0_0_1.value },
   19215    NULL,
   19216 };
   19217 
   19218 #include "compiler/nir/nir_search_helpers.h"
   19219 static const nir_search_constant replace233_0_1_0_1 = {
   19220    { nir_search_value_constant, 0 },
   19221    nir_type_int, { 0x7f /* 127 */ },
   19222 };
   19223 #include "compiler/nir/nir_search_helpers.h"
   19224 static const nir_search_expression replace233_0_1_0 = {
   19225    { nir_search_value_expression, 0 },
   19226    false,
   19227    nir_op_iadd,
   19228    { &replace233_0_1_0_0.value, &replace233_0_1_0_1.value },
   19229    NULL,
   19230 };
   19231 
   19232 #include "compiler/nir/nir_search_helpers.h"
   19233 static const nir_search_constant replace233_0_1_1 = {
   19234    { nir_search_value_constant, 0 },
   19235    nir_type_int, { 0x17 /* 23 */ },
   19236 };
   19237 #include "compiler/nir/nir_search_helpers.h"
   19238 static const nir_search_expression replace233_0_1 = {
   19239    { nir_search_value_expression, 0 },
   19240    false,
   19241    nir_op_ishl,
   19242    { &replace233_0_1_0.value, &replace233_0_1_1.value },
   19243    NULL,
   19244 };
   19245 #include "compiler/nir/nir_search_helpers.h"
   19246 static const nir_search_expression replace233_0 = {
   19247    { nir_search_value_expression, 0 },
   19248    false,
   19249    nir_op_fmul,
   19250    { &replace233_0_0.value, &replace233_0_1.value },
   19251    NULL,
   19252 };
   19253 
   19254 #include "compiler/nir/nir_search_helpers.h"
   19255 static const nir_search_variable replace233_1_0_0_0_0_0 = {
   19256    { nir_search_value_variable, 0 },
   19257    1, /* exp */
   19258    false,
   19259    nir_type_invalid,
   19260    NULL,
   19261 };
   19262 
   19263 #include "compiler/nir/nir_search_helpers.h"
   19264 static const nir_search_constant replace233_1_0_0_0_0_1 = {
   19265    { nir_search_value_constant, 0 },
   19266    nir_type_int, { -0xfc /* -252 */ },
   19267 };
   19268 #include "compiler/nir/nir_search_helpers.h"
   19269 static const nir_search_expression replace233_1_0_0_0_0 = {
   19270    { nir_search_value_expression, 0 },
   19271    false,
   19272    nir_op_imax,
   19273    { &replace233_1_0_0_0_0_0.value, &replace233_1_0_0_0_0_1.value },
   19274    NULL,
   19275 };
   19276 
   19277 #include "compiler/nir/nir_search_helpers.h"
   19278 static const nir_search_constant replace233_1_0_0_0_1 = {
   19279    { nir_search_value_constant, 0 },
   19280    nir_type_int, { 0xfe /* 254 */ },
   19281 };
   19282 #include "compiler/nir/nir_search_helpers.h"
   19283 static const nir_search_expression replace233_1_0_0_0 = {
   19284    { nir_search_value_expression, 0 },
   19285    false,
   19286    nir_op_imin,
   19287    { &replace233_1_0_0_0_0.value, &replace233_1_0_0_0_1.value },
   19288    NULL,
   19289 };
   19290 
   19291 #include "compiler/nir/nir_search_helpers.h"
   19292 static const nir_search_variable replace233_1_0_0_1_0_0_0 = {
   19293    { nir_search_value_variable, 0 },
   19294    1, /* exp */
   19295    false,
   19296    nir_type_invalid,
   19297    NULL,
   19298 };
   19299 
   19300 #include "compiler/nir/nir_search_helpers.h"
   19301 static const nir_search_constant replace233_1_0_0_1_0_0_1 = {
   19302    { nir_search_value_constant, 0 },
   19303    nir_type_int, { -0xfc /* -252 */ },
   19304 };
   19305 #include "compiler/nir/nir_search_helpers.h"
   19306 static const nir_search_expression replace233_1_0_0_1_0_0 = {
   19307    { nir_search_value_expression, 0 },
   19308    false,
   19309    nir_op_imax,
   19310    { &replace233_1_0_0_1_0_0_0.value, &replace233_1_0_0_1_0_0_1.value },
   19311    NULL,
   19312 };
   19313 
   19314 #include "compiler/nir/nir_search_helpers.h"
   19315 static const nir_search_constant replace233_1_0_0_1_0_1 = {
   19316    { nir_search_value_constant, 0 },
   19317    nir_type_int, { 0xfe /* 254 */ },
   19318 };
   19319 #include "compiler/nir/nir_search_helpers.h"
   19320 static const nir_search_expression replace233_1_0_0_1_0 = {
   19321    { nir_search_value_expression, 0 },
   19322    false,
   19323    nir_op_imin,
   19324    { &replace233_1_0_0_1_0_0.value, &replace233_1_0_0_1_0_1.value },
   19325    NULL,
   19326 };
   19327 
   19328 #include "compiler/nir/nir_search_helpers.h"
   19329 static const nir_search_constant replace233_1_0_0_1_1 = {
   19330    { nir_search_value_constant, 0 },
   19331    nir_type_int, { 0x1 /* 1 */ },
   19332 };
   19333 #include "compiler/nir/nir_search_helpers.h"
   19334 static const nir_search_expression replace233_1_0_0_1 = {
   19335    { nir_search_value_expression, 0 },
   19336    false,
   19337    nir_op_ishr,
   19338    { &replace233_1_0_0_1_0.value, &replace233_1_0_0_1_1.value },
   19339    NULL,
   19340 };
   19341 #include "compiler/nir/nir_search_helpers.h"
   19342 static const nir_search_expression replace233_1_0_0 = {
   19343    { nir_search_value_expression, 0 },
   19344    false,
   19345    nir_op_isub,
   19346    { &replace233_1_0_0_0.value, &replace233_1_0_0_1.value },
   19347    NULL,
   19348 };
   19349 
   19350 #include "compiler/nir/nir_search_helpers.h"
   19351 static const nir_search_constant replace233_1_0_1 = {
   19352    { nir_search_value_constant, 0 },
   19353    nir_type_int, { 0x7f /* 127 */ },
   19354 };
   19355 #include "compiler/nir/nir_search_helpers.h"
   19356 static const nir_search_expression replace233_1_0 = {
   19357    { nir_search_value_expression, 0 },
   19358    false,
   19359    nir_op_iadd,
   19360    { &replace233_1_0_0.value, &replace233_1_0_1.value },
   19361    NULL,
   19362 };
   19363 
   19364 #include "compiler/nir/nir_search_helpers.h"
   19365 static const nir_search_constant replace233_1_1 = {
   19366    { nir_search_value_constant, 0 },
   19367    nir_type_int, { 0x17 /* 23 */ },
   19368 };
   19369 #include "compiler/nir/nir_search_helpers.h"
   19370 static const nir_search_expression replace233_1 = {
   19371    { nir_search_value_expression, 0 },
   19372    false,
   19373    nir_op_ishl,
   19374    { &replace233_1_0.value, &replace233_1_1.value },
   19375    NULL,
   19376 };
   19377 #include "compiler/nir/nir_search_helpers.h"
   19378 static const nir_search_expression replace233 = {
   19379    { nir_search_value_expression, 0 },
   19380    false,
   19381    nir_op_fmul,
   19382    { &replace233_0.value, &replace233_1.value },
   19383    NULL,
   19384 };
   19385 
   19386 #include "compiler/nir/nir_search_helpers.h"
   19387 static const nir_search_variable search234_0 = {
   19388    { nir_search_value_variable, 0 },
   19389    0, /* x */
   19390    false,
   19391    nir_type_invalid,
   19392    NULL,
   19393 };
   19394 
   19395 #include "compiler/nir/nir_search_helpers.h"
   19396 static const nir_search_variable search234_1 = {
   19397    { nir_search_value_variable, 0 },
   19398    1, /* exp */
   19399    false,
   19400    nir_type_invalid,
   19401    NULL,
   19402 };
   19403 #include "compiler/nir/nir_search_helpers.h"
   19404 static const nir_search_expression search234 = {
   19405    { nir_search_value_expression, 64 },
   19406    false,
   19407    nir_op_ldexp,
   19408    { &search234_0.value, &search234_1.value },
   19409    NULL,
   19410 };
   19411 
   19412 #include "compiler/nir/nir_search_helpers.h"
   19413 static const nir_search_variable replace234_0_0 = {
   19414    { nir_search_value_variable, 0 },
   19415    0, /* x */
   19416    false,
   19417    nir_type_invalid,
   19418    NULL,
   19419 };
   19420 
   19421 #include "compiler/nir/nir_search_helpers.h"
   19422 static const nir_search_constant replace234_0_1_0 = {
   19423    { nir_search_value_constant, 0 },
   19424    nir_type_int, { 0x0 /* 0 */ },
   19425 };
   19426 
   19427 #include "compiler/nir/nir_search_helpers.h"
   19428 static const nir_search_variable replace234_0_1_1_0_0_0_0_0 = {
   19429    { nir_search_value_variable, 0 },
   19430    1, /* exp */
   19431    false,
   19432    nir_type_invalid,
   19433    NULL,
   19434 };
   19435 
   19436 #include "compiler/nir/nir_search_helpers.h"
   19437 static const nir_search_constant replace234_0_1_1_0_0_0_0_1 = {
   19438    { nir_search_value_constant, 0 },
   19439    nir_type_int, { -0x7fc /* -2044 */ },
   19440 };
   19441 #include "compiler/nir/nir_search_helpers.h"
   19442 static const nir_search_expression replace234_0_1_1_0_0_0_0 = {
   19443    { nir_search_value_expression, 0 },
   19444    false,
   19445    nir_op_imax,
   19446    { &replace234_0_1_1_0_0_0_0_0.value, &replace234_0_1_1_0_0_0_0_1.value },
   19447    NULL,
   19448 };
   19449 
   19450 #include "compiler/nir/nir_search_helpers.h"
   19451 static const nir_search_constant replace234_0_1_1_0_0_0_1 = {
   19452    { nir_search_value_constant, 0 },
   19453    nir_type_int, { 0x7fe /* 2046 */ },
   19454 };
   19455 #include "compiler/nir/nir_search_helpers.h"
   19456 static const nir_search_expression replace234_0_1_1_0_0_0 = {
   19457    { nir_search_value_expression, 0 },
   19458    false,
   19459    nir_op_imin,
   19460    { &replace234_0_1_1_0_0_0_0.value, &replace234_0_1_1_0_0_0_1.value },
   19461    NULL,
   19462 };
   19463 
   19464 #include "compiler/nir/nir_search_helpers.h"
   19465 static const nir_search_constant replace234_0_1_1_0_0_1 = {
   19466    { nir_search_value_constant, 0 },
   19467    nir_type_int, { 0x1 /* 1 */ },
   19468 };
   19469 #include "compiler/nir/nir_search_helpers.h"
   19470 static const nir_search_expression replace234_0_1_1_0_0 = {
   19471    { nir_search_value_expression, 0 },
   19472    false,
   19473    nir_op_ishr,
   19474    { &replace234_0_1_1_0_0_0.value, &replace234_0_1_1_0_0_1.value },
   19475    NULL,
   19476 };
   19477 
   19478 #include "compiler/nir/nir_search_helpers.h"
   19479 static const nir_search_constant replace234_0_1_1_0_1 = {
   19480    { nir_search_value_constant, 0 },
   19481    nir_type_int, { 0x3ff /* 1023 */ },
   19482 };
   19483 #include "compiler/nir/nir_search_helpers.h"
   19484 static const nir_search_expression replace234_0_1_1_0 = {
   19485    { nir_search_value_expression, 0 },
   19486    false,
   19487    nir_op_iadd,
   19488    { &replace234_0_1_1_0_0.value, &replace234_0_1_1_0_1.value },
   19489    NULL,
   19490 };
   19491 
   19492 #include "compiler/nir/nir_search_helpers.h"
   19493 static const nir_search_constant replace234_0_1_1_1 = {
   19494    { nir_search_value_constant, 0 },
   19495    nir_type_int, { 0x14 /* 20 */ },
   19496 };
   19497 #include "compiler/nir/nir_search_helpers.h"
   19498 static const nir_search_expression replace234_0_1_1 = {
   19499    { nir_search_value_expression, 0 },
   19500    false,
   19501    nir_op_ishl,
   19502    { &replace234_0_1_1_0.value, &replace234_0_1_1_1.value },
   19503    NULL,
   19504 };
   19505 #include "compiler/nir/nir_search_helpers.h"
   19506 static const nir_search_expression replace234_0_1 = {
   19507    { nir_search_value_expression, 0 },
   19508    false,
   19509    nir_op_pack_double_2x32_split,
   19510    { &replace234_0_1_0.value, &replace234_0_1_1.value },
   19511    NULL,
   19512 };
   19513 #include "compiler/nir/nir_search_helpers.h"
   19514 static const nir_search_expression replace234_0 = {
   19515    { nir_search_value_expression, 0 },
   19516    false,
   19517    nir_op_fmul,
   19518    { &replace234_0_0.value, &replace234_0_1.value },
   19519    NULL,
   19520 };
   19521 
   19522 #include "compiler/nir/nir_search_helpers.h"
   19523 static const nir_search_constant replace234_1_0 = {
   19524    { nir_search_value_constant, 0 },
   19525    nir_type_int, { 0x0 /* 0 */ },
   19526 };
   19527 
   19528 #include "compiler/nir/nir_search_helpers.h"
   19529 static const nir_search_variable replace234_1_1_0_0_0_0_0 = {
   19530    { nir_search_value_variable, 0 },
   19531    1, /* exp */
   19532    false,
   19533    nir_type_invalid,
   19534    NULL,
   19535 };
   19536 
   19537 #include "compiler/nir/nir_search_helpers.h"
   19538 static const nir_search_constant replace234_1_1_0_0_0_0_1 = {
   19539    { nir_search_value_constant, 0 },
   19540    nir_type_int, { -0x7fc /* -2044 */ },
   19541 };
   19542 #include "compiler/nir/nir_search_helpers.h"
   19543 static const nir_search_expression replace234_1_1_0_0_0_0 = {
   19544    { nir_search_value_expression, 0 },
   19545    false,
   19546    nir_op_imax,
   19547    { &replace234_1_1_0_0_0_0_0.value, &replace234_1_1_0_0_0_0_1.value },
   19548    NULL,
   19549 };
   19550 
   19551 #include "compiler/nir/nir_search_helpers.h"
   19552 static const nir_search_constant replace234_1_1_0_0_0_1 = {
   19553    { nir_search_value_constant, 0 },
   19554    nir_type_int, { 0x7fe /* 2046 */ },
   19555 };
   19556 #include "compiler/nir/nir_search_helpers.h"
   19557 static const nir_search_expression replace234_1_1_0_0_0 = {
   19558    { nir_search_value_expression, 0 },
   19559    false,
   19560    nir_op_imin,
   19561    { &replace234_1_1_0_0_0_0.value, &replace234_1_1_0_0_0_1.value },
   19562    NULL,
   19563 };
   19564 
   19565 #include "compiler/nir/nir_search_helpers.h"
   19566 static const nir_search_variable replace234_1_1_0_0_1_0_0_0 = {
   19567    { nir_search_value_variable, 0 },
   19568    1, /* exp */
   19569    false,
   19570    nir_type_invalid,
   19571    NULL,
   19572 };
   19573 
   19574 #include "compiler/nir/nir_search_helpers.h"
   19575 static const nir_search_constant replace234_1_1_0_0_1_0_0_1 = {
   19576    { nir_search_value_constant, 0 },
   19577    nir_type_int, { -0x7fc /* -2044 */ },
   19578 };
   19579 #include "compiler/nir/nir_search_helpers.h"
   19580 static const nir_search_expression replace234_1_1_0_0_1_0_0 = {
   19581    { nir_search_value_expression, 0 },
   19582    false,
   19583    nir_op_imax,
   19584    { &replace234_1_1_0_0_1_0_0_0.value, &replace234_1_1_0_0_1_0_0_1.value },
   19585    NULL,
   19586 };
   19587 
   19588 #include "compiler/nir/nir_search_helpers.h"
   19589 static const nir_search_constant replace234_1_1_0_0_1_0_1 = {
   19590    { nir_search_value_constant, 0 },
   19591    nir_type_int, { 0x7fe /* 2046 */ },
   19592 };
   19593 #include "compiler/nir/nir_search_helpers.h"
   19594 static const nir_search_expression replace234_1_1_0_0_1_0 = {
   19595    { nir_search_value_expression, 0 },
   19596    false,
   19597    nir_op_imin,
   19598    { &replace234_1_1_0_0_1_0_0.value, &replace234_1_1_0_0_1_0_1.value },
   19599    NULL,
   19600 };
   19601 
   19602 #include "compiler/nir/nir_search_helpers.h"
   19603 static const nir_search_constant replace234_1_1_0_0_1_1 = {
   19604    { nir_search_value_constant, 0 },
   19605    nir_type_int, { 0x1 /* 1 */ },
   19606 };
   19607 #include "compiler/nir/nir_search_helpers.h"
   19608 static const nir_search_expression replace234_1_1_0_0_1 = {
   19609    { nir_search_value_expression, 0 },
   19610    false,
   19611    nir_op_ishr,
   19612    { &replace234_1_1_0_0_1_0.value, &replace234_1_1_0_0_1_1.value },
   19613    NULL,
   19614 };
   19615 #include "compiler/nir/nir_search_helpers.h"
   19616 static const nir_search_expression replace234_1_1_0_0 = {
   19617    { nir_search_value_expression, 0 },
   19618    false,
   19619    nir_op_isub,
   19620    { &replace234_1_1_0_0_0.value, &replace234_1_1_0_0_1.value },
   19621    NULL,
   19622 };
   19623 
   19624 #include "compiler/nir/nir_search_helpers.h"
   19625 static const nir_search_constant replace234_1_1_0_1 = {
   19626    { nir_search_value_constant, 0 },
   19627    nir_type_int, { 0x3ff /* 1023 */ },
   19628 };
   19629 #include "compiler/nir/nir_search_helpers.h"
   19630 static const nir_search_expression replace234_1_1_0 = {
   19631    { nir_search_value_expression, 0 },
   19632    false,
   19633    nir_op_iadd,
   19634    { &replace234_1_1_0_0.value, &replace234_1_1_0_1.value },
   19635    NULL,
   19636 };
   19637 
   19638 #include "compiler/nir/nir_search_helpers.h"
   19639 static const nir_search_constant replace234_1_1_1 = {
   19640    { nir_search_value_constant, 0 },
   19641    nir_type_int, { 0x14 /* 20 */ },
   19642 };
   19643 #include "compiler/nir/nir_search_helpers.h"
   19644 static const nir_search_expression replace234_1_1 = {
   19645    { nir_search_value_expression, 0 },
   19646    false,
   19647    nir_op_ishl,
   19648    { &replace234_1_1_0.value, &replace234_1_1_1.value },
   19649    NULL,
   19650 };
   19651 #include "compiler/nir/nir_search_helpers.h"
   19652 static const nir_search_expression replace234_1 = {
   19653    { nir_search_value_expression, 0 },
   19654    false,
   19655    nir_op_pack_double_2x32_split,
   19656    { &replace234_1_0.value, &replace234_1_1.value },
   19657    NULL,
   19658 };
   19659 #include "compiler/nir/nir_search_helpers.h"
   19660 static const nir_search_expression replace234 = {
   19661    { nir_search_value_expression, 0 },
   19662    false,
   19663    nir_op_fmul,
   19664    { &replace234_0.value, &replace234_1.value },
   19665    NULL,
   19666 };
   19667 
   19668 static const struct transform nir_opt_algebraic_ldexp_xforms[] = {
   19669    { &search233, &replace233.value, 0 },
   19670    { &search234, &replace234.value, 0 },
   19671 };
   19672 
   19673 #include "compiler/nir/nir_search_helpers.h"
   19674 static const nir_search_variable search223_0 = {
   19675    { nir_search_value_variable, 0 },
   19676    0, /* a */
   19677    false,
   19678    nir_type_invalid,
   19679    NULL,
   19680 };
   19681 
   19682 #include "compiler/nir/nir_search_helpers.h"
   19683 static const nir_search_variable search223_1 = {
   19684    { nir_search_value_variable, 0 },
   19685    1, /* b */
   19686    false,
   19687    nir_type_invalid,
   19688    NULL,
   19689 };
   19690 #include "compiler/nir/nir_search_helpers.h"
   19691 static const nir_search_expression search223 = {
   19692    { nir_search_value_expression, 0 },
   19693    false,
   19694    nir_op_extract_i16,
   19695    { &search223_0.value, &search223_1.value },
   19696    NULL,
   19697 };
   19698 
   19699 #include "compiler/nir/nir_search_helpers.h"
   19700 static const nir_search_variable replace223_0_0 = {
   19701    { nir_search_value_variable, 0 },
   19702    0, /* a */
   19703    false,
   19704    nir_type_invalid,
   19705    NULL,
   19706 };
   19707 
   19708 #include "compiler/nir/nir_search_helpers.h"
   19709 static const nir_search_constant replace223_0_1_0_0 = {
   19710    { nir_search_value_constant, 0 },
   19711    nir_type_int, { 0x1 /* 1 */ },
   19712 };
   19713 
   19714 #include "compiler/nir/nir_search_helpers.h"
   19715 static const nir_search_variable replace223_0_1_0_1 = {
   19716    { nir_search_value_variable, 0 },
   19717    1, /* b */
   19718    false,
   19719    nir_type_invalid,
   19720    NULL,
   19721 };
   19722 #include "compiler/nir/nir_search_helpers.h"
   19723 static const nir_search_expression replace223_0_1_0 = {
   19724    { nir_search_value_expression, 0 },
   19725    false,
   19726    nir_op_isub,
   19727    { &replace223_0_1_0_0.value, &replace223_0_1_0_1.value },
   19728    NULL,
   19729 };
   19730 
   19731 #include "compiler/nir/nir_search_helpers.h"
   19732 static const nir_search_constant replace223_0_1_1 = {
   19733    { nir_search_value_constant, 0 },
   19734    nir_type_int, { 0x10 /* 16 */ },
   19735 };
   19736 #include "compiler/nir/nir_search_helpers.h"
   19737 static const nir_search_expression replace223_0_1 = {
   19738    { nir_search_value_expression, 0 },
   19739    false,
   19740    nir_op_imul,
   19741    { &replace223_0_1_0.value, &replace223_0_1_1.value },
   19742    NULL,
   19743 };
   19744 #include "compiler/nir/nir_search_helpers.h"
   19745 static const nir_search_expression replace223_0 = {
   19746    { nir_search_value_expression, 0 },
   19747    false,
   19748    nir_op_ishl,
   19749    { &replace223_0_0.value, &replace223_0_1.value },
   19750    NULL,
   19751 };
   19752 
   19753 #include "compiler/nir/nir_search_helpers.h"
   19754 static const nir_search_constant replace223_1 = {
   19755    { nir_search_value_constant, 0 },
   19756    nir_type_int, { 0x10 /* 16 */ },
   19757 };
   19758 #include "compiler/nir/nir_search_helpers.h"
   19759 static const nir_search_expression replace223 = {
   19760    { nir_search_value_expression, 0 },
   19761    false,
   19762    nir_op_ishr,
   19763    { &replace223_0.value, &replace223_1.value },
   19764    NULL,
   19765 };
   19766 
   19767 static const struct transform nir_opt_algebraic_extract_i16_xforms[] = {
   19768    { &search223, &replace223.value, 28 },
   19769 };
   19770 
   19771 static bool
   19772 nir_opt_algebraic_block(nir_block *block, const bool *condition_flags,
   19773                    void *mem_ctx)
   19774 {
   19775    bool progress = false;
   19776 
   19777    nir_foreach_instr_reverse_safe(instr, block) {
   19778       if (instr->type != nir_instr_type_alu)
   19779          continue;
   19780 
   19781       nir_alu_instr *alu = nir_instr_as_alu(instr);
   19782       if (!alu->dest.dest.is_ssa)
   19783          continue;
   19784 
   19785       switch (alu->op) {
   19786       case nir_op_iand:
   19787          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_iand_xforms); i++) {
   19788             const struct transform *xform = &nir_opt_algebraic_iand_xforms[i];
   19789             if (condition_flags[xform->condition_offset] &&
   19790                 nir_replace_instr(alu, xform->search, xform->replace,
   19791                                   mem_ctx)) {
   19792                progress = true;
   19793                break;
   19794             }
   19795          }
   19796          break;
   19797       case nir_op_i2b:
   19798          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_i2b_xforms); i++) {
   19799             const struct transform *xform = &nir_opt_algebraic_i2b_xforms[i];
   19800             if (condition_flags[xform->condition_offset] &&
   19801                 nir_replace_instr(alu, xform->search, xform->replace,
   19802                                   mem_ctx)) {
   19803                progress = true;
   19804                break;
   19805             }
   19806          }
   19807          break;
   19808       case nir_op_ixor:
   19809          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ixor_xforms); i++) {
   19810             const struct transform *xform = &nir_opt_algebraic_ixor_xforms[i];
   19811             if (condition_flags[xform->condition_offset] &&
   19812                 nir_replace_instr(alu, xform->search, xform->replace,
   19813                                   mem_ctx)) {
   19814                progress = true;
   19815                break;
   19816             }
   19817          }
   19818          break;
   19819       case nir_op_seq:
   19820          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_seq_xforms); i++) {
   19821             const struct transform *xform = &nir_opt_algebraic_seq_xforms[i];
   19822             if (condition_flags[xform->condition_offset] &&
   19823                 nir_replace_instr(alu, xform->search, xform->replace,
   19824                                   mem_ctx)) {
   19825                progress = true;
   19826                break;
   19827             }
   19828          }
   19829          break;
   19830       case nir_op_ilt:
   19831          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ilt_xforms); i++) {
   19832             const struct transform *xform = &nir_opt_algebraic_ilt_xforms[i];
   19833             if (condition_flags[xform->condition_offset] &&
   19834                 nir_replace_instr(alu, xform->search, xform->replace,
   19835                                   mem_ctx)) {
   19836                progress = true;
   19837                break;
   19838             }
   19839          }
   19840          break;
   19841       case nir_op_umod:
   19842          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_umod_xforms); i++) {
   19843             const struct transform *xform = &nir_opt_algebraic_umod_xforms[i];
   19844             if (condition_flags[xform->condition_offset] &&
   19845                 nir_replace_instr(alu, xform->search, xform->replace,
   19846                                   mem_ctx)) {
   19847                progress = true;
   19848                break;
   19849             }
   19850          }
   19851          break;
   19852       case nir_op_imul:
   19853          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_imul_xforms); i++) {
   19854             const struct transform *xform = &nir_opt_algebraic_imul_xforms[i];
   19855             if (condition_flags[xform->condition_offset] &&
   19856                 nir_replace_instr(alu, xform->search, xform->replace,
   19857                                   mem_ctx)) {
   19858                progress = true;
   19859                break;
   19860             }
   19861          }
   19862          break;
   19863       case nir_op_uge:
   19864          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_uge_xforms); i++) {
   19865             const struct transform *xform = &nir_opt_algebraic_uge_xforms[i];
   19866             if (condition_flags[xform->condition_offset] &&
   19867                 nir_replace_instr(alu, xform->search, xform->replace,
   19868                                   mem_ctx)) {
   19869                progress = true;
   19870                break;
   19871             }
   19872          }
   19873          break;
   19874       case nir_op_ineg:
   19875          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ineg_xforms); i++) {
   19876             const struct transform *xform = &nir_opt_algebraic_ineg_xforms[i];
   19877             if (condition_flags[xform->condition_offset] &&
   19878                 nir_replace_instr(alu, xform->search, xform->replace,
   19879                                   mem_ctx)) {
   19880                progress = true;
   19881                break;
   19882             }
   19883          }
   19884          break;
   19885       case nir_op_fmul:
   19886          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fmul_xforms); i++) {
   19887             const struct transform *xform = &nir_opt_algebraic_fmul_xforms[i];
   19888             if (condition_flags[xform->condition_offset] &&
   19889                 nir_replace_instr(alu, xform->search, xform->replace,
   19890                                   mem_ctx)) {
   19891                progress = true;
   19892                break;
   19893             }
   19894          }
   19895          break;
   19896       case nir_op_ubitfield_extract:
   19897          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ubitfield_extract_xforms); i++) {
   19898             const struct transform *xform = &nir_opt_algebraic_ubitfield_extract_xforms[i];
   19899             if (condition_flags[xform->condition_offset] &&
   19900                 nir_replace_instr(alu, xform->search, xform->replace,
   19901                                   mem_ctx)) {
   19902                progress = true;
   19903                break;
   19904             }
   19905          }
   19906          break;
   19907       case nir_op_ffma:
   19908          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ffma_xforms); i++) {
   19909             const struct transform *xform = &nir_opt_algebraic_ffma_xforms[i];
   19910             if (condition_flags[xform->condition_offset] &&
   19911                 nir_replace_instr(alu, xform->search, xform->replace,
   19912                                   mem_ctx)) {
   19913                progress = true;
   19914                break;
   19915             }
   19916          }
   19917          break;
   19918       case nir_op_umin:
   19919          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_umin_xforms); i++) {
   19920             const struct transform *xform = &nir_opt_algebraic_umin_xforms[i];
   19921             if (condition_flags[xform->condition_offset] &&
   19922                 nir_replace_instr(alu, xform->search, xform->replace,
   19923                                   mem_ctx)) {
   19924                progress = true;
   19925                break;
   19926             }
   19927          }
   19928          break;
   19929       case nir_op_umax:
   19930          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_umax_xforms); i++) {
   19931             const struct transform *xform = &nir_opt_algebraic_umax_xforms[i];
   19932             if (condition_flags[xform->condition_offset] &&
   19933                 nir_replace_instr(alu, xform->search, xform->replace,
   19934                                   mem_ctx)) {
   19935                progress = true;
   19936                break;
   19937             }
   19938          }
   19939          break;
   19940       case nir_op_bcsel:
   19941          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_bcsel_xforms); i++) {
   19942             const struct transform *xform = &nir_opt_algebraic_bcsel_xforms[i];
   19943             if (condition_flags[xform->condition_offset] &&
   19944                 nir_replace_instr(alu, xform->search, xform->replace,
   19945                                   mem_ctx)) {
   19946                progress = true;
   19947                break;
   19948             }
   19949          }
   19950          break;
   19951       case nir_op_sge:
   19952          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_sge_xforms); i++) {
   19953             const struct transform *xform = &nir_opt_algebraic_sge_xforms[i];
   19954             if (condition_flags[xform->condition_offset] &&
   19955                 nir_replace_instr(alu, xform->search, xform->replace,
   19956                                   mem_ctx)) {
   19957                progress = true;
   19958                break;
   19959             }
   19960          }
   19961          break;
   19962       case nir_op_fsqrt:
   19963          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fsqrt_xforms); i++) {
   19964             const struct transform *xform = &nir_opt_algebraic_fsqrt_xforms[i];
   19965             if (condition_flags[xform->condition_offset] &&
   19966                 nir_replace_instr(alu, xform->search, xform->replace,
   19967                                   mem_ctx)) {
   19968                progress = true;
   19969                break;
   19970             }
   19971          }
   19972          break;
   19973       case nir_op_iadd:
   19974          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_iadd_xforms); i++) {
   19975             const struct transform *xform = &nir_opt_algebraic_iadd_xforms[i];
   19976             if (condition_flags[xform->condition_offset] &&
   19977                 nir_replace_instr(alu, xform->search, xform->replace,
   19978                                   mem_ctx)) {
   19979                progress = true;
   19980                break;
   19981             }
   19982          }
   19983          break;
   19984       case nir_op_pack_unorm_2x16:
   19985          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_pack_unorm_2x16_xforms); i++) {
   19986             const struct transform *xform = &nir_opt_algebraic_pack_unorm_2x16_xforms[i];
   19987             if (condition_flags[xform->condition_offset] &&
   19988                 nir_replace_instr(alu, xform->search, xform->replace,
   19989                                   mem_ctx)) {
   19990                progress = true;
   19991                break;
   19992             }
   19993          }
   19994          break;
   19995       case nir_op_pack_unorm_4x8:
   19996          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_pack_unorm_4x8_xforms); i++) {
   19997             const struct transform *xform = &nir_opt_algebraic_pack_unorm_4x8_xforms[i];
   19998             if (condition_flags[xform->condition_offset] &&
   19999                 nir_replace_instr(alu, xform->search, xform->replace,
   20000                                   mem_ctx)) {
   20001                progress = true;
   20002                break;
   20003             }
   20004          }
   20005          break;
   20006       case nir_op_pack_snorm_4x8:
   20007          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_pack_snorm_4x8_xforms); i++) {
   20008             const struct transform *xform = &nir_opt_algebraic_pack_snorm_4x8_xforms[i];
   20009             if (condition_flags[xform->condition_offset] &&
   20010                 nir_replace_instr(alu, xform->search, xform->replace,
   20011                                   mem_ctx)) {
   20012                progress = true;
   20013                break;
   20014             }
   20015          }
   20016          break;
   20017       case nir_op_fand:
   20018          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fand_xforms); i++) {
   20019             const struct transform *xform = &nir_opt_algebraic_fand_xforms[i];
   20020             if (condition_flags[xform->condition_offset] &&
   20021                 nir_replace_instr(alu, xform->search, xform->replace,
   20022                                   mem_ctx)) {
   20023                progress = true;
   20024                break;
   20025             }
   20026          }
   20027          break;
   20028       case nir_op_fabs:
   20029          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fabs_xforms); i++) {
   20030             const struct transform *xform = &nir_opt_algebraic_fabs_xforms[i];
   20031             if (condition_flags[xform->condition_offset] &&
   20032                 nir_replace_instr(alu, xform->search, xform->replace,
   20033                                   mem_ctx)) {
   20034                progress = true;
   20035                break;
   20036             }
   20037          }
   20038          break;
   20039       case nir_op_imod:
   20040          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_imod_xforms); i++) {
   20041             const struct transform *xform = &nir_opt_algebraic_imod_xforms[i];
   20042             if (condition_flags[xform->condition_offset] &&
   20043                 nir_replace_instr(alu, xform->search, xform->replace,
   20044                                   mem_ctx)) {
   20045                progress = true;
   20046                break;
   20047             }
   20048          }
   20049          break;
   20050       case nir_op_ieq:
   20051          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ieq_xforms); i++) {
   20052             const struct transform *xform = &nir_opt_algebraic_ieq_xforms[i];
   20053             if (condition_flags[xform->condition_offset] &&
   20054                 nir_replace_instr(alu, xform->search, xform->replace,
   20055                                   mem_ctx)) {
   20056                progress = true;
   20057                break;
   20058             }
   20059          }
   20060          break;
   20061       case nir_op_imin:
   20062          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_imin_xforms); i++) {
   20063             const struct transform *xform = &nir_opt_algebraic_imin_xforms[i];
   20064             if (condition_flags[xform->condition_offset] &&
   20065                 nir_replace_instr(alu, xform->search, xform->replace,
   20066                                   mem_ctx)) {
   20067                progress = true;
   20068                break;
   20069             }
   20070          }
   20071          break;
   20072       case nir_op_frsq:
   20073          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_frsq_xforms); i++) {
   20074             const struct transform *xform = &nir_opt_algebraic_frsq_xforms[i];
   20075             if (condition_flags[xform->condition_offset] &&
   20076                 nir_replace_instr(alu, xform->search, xform->replace,
   20077                                   mem_ctx)) {
   20078                progress = true;
   20079                break;
   20080             }
   20081          }
   20082          break;
   20083       case nir_op_usadd_4x8:
   20084          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_usadd_4x8_xforms); i++) {
   20085             const struct transform *xform = &nir_opt_algebraic_usadd_4x8_xforms[i];
   20086             if (condition_flags[xform->condition_offset] &&
   20087                 nir_replace_instr(alu, xform->search, xform->replace,
   20088                                   mem_ctx)) {
   20089                progress = true;
   20090                break;
   20091             }
   20092          }
   20093          break;
   20094       case nir_op_idiv:
   20095          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_idiv_xforms); i++) {
   20096             const struct transform *xform = &nir_opt_algebraic_idiv_xforms[i];
   20097             if (condition_flags[xform->condition_offset] &&
   20098                 nir_replace_instr(alu, xform->search, xform->replace,
   20099                                   mem_ctx)) {
   20100                progress = true;
   20101                break;
   20102             }
   20103          }
   20104          break;
   20105       case nir_op_extract_u8:
   20106          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_extract_u8_xforms); i++) {
   20107             const struct transform *xform = &nir_opt_algebraic_extract_u8_xforms[i];
   20108             if (condition_flags[xform->condition_offset] &&
   20109                 nir_replace_instr(alu, xform->search, xform->replace,
   20110                                   mem_ctx)) {
   20111                progress = true;
   20112                break;
   20113             }
   20114          }
   20115          break;
   20116       case nir_op_pack_snorm_2x16:
   20117          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_pack_snorm_2x16_xforms); i++) {
   20118             const struct transform *xform = &nir_opt_algebraic_pack_snorm_2x16_xforms[i];
   20119             if (condition_flags[xform->condition_offset] &&
   20120                 nir_replace_instr(alu, xform->search, xform->replace,
   20121                                   mem_ctx)) {
   20122                progress = true;
   20123                break;
   20124             }
   20125          }
   20126          break;
   20127       case nir_op_fpow:
   20128          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fpow_xforms); i++) {
   20129             const struct transform *xform = &nir_opt_algebraic_fpow_xforms[i];
   20130             if (condition_flags[xform->condition_offset] &&
   20131                 nir_replace_instr(alu, xform->search, xform->replace,
   20132                                   mem_ctx)) {
   20133                progress = true;
   20134                break;
   20135             }
   20136          }
   20137          break;
   20138       case nir_op_ige:
   20139          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ige_xforms); i++) {
   20140             const struct transform *xform = &nir_opt_algebraic_ige_xforms[i];
   20141             if (condition_flags[xform->condition_offset] &&
   20142                 nir_replace_instr(alu, xform->search, xform->replace,
   20143                                   mem_ctx)) {
   20144                progress = true;
   20145                break;
   20146             }
   20147          }
   20148          break;
   20149       case nir_op_fdiv:
   20150          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fdiv_xforms); i++) {
   20151             const struct transform *xform = &nir_opt_algebraic_fdiv_xforms[i];
   20152             if (condition_flags[xform->condition_offset] &&
   20153                 nir_replace_instr(alu, xform->search, xform->replace,
   20154                                   mem_ctx)) {
   20155                progress = true;
   20156                break;
   20157             }
   20158          }
   20159          break;
   20160       case nir_op_ffract:
   20161          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ffract_xforms); i++) {
   20162             const struct transform *xform = &nir_opt_algebraic_ffract_xforms[i];
   20163             if (condition_flags[xform->condition_offset] &&
   20164                 nir_replace_instr(alu, xform->search, xform->replace,
   20165                                   mem_ctx)) {
   20166                progress = true;
   20167                break;
   20168             }
   20169          }
   20170          break;
   20171       case nir_op_fadd:
   20172          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fadd_xforms); i++) {
   20173             const struct transform *xform = &nir_opt_algebraic_fadd_xforms[i];
   20174             if (condition_flags[xform->condition_offset] &&
   20175                 nir_replace_instr(alu, xform->search, xform->replace,
   20176                                   mem_ctx)) {
   20177                progress = true;
   20178                break;
   20179             }
   20180          }
   20181          break;
   20182       case nir_op_ishl:
   20183          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ishl_xforms); i++) {
   20184             const struct transform *xform = &nir_opt_algebraic_ishl_xforms[i];
   20185             if (condition_flags[xform->condition_offset] &&
   20186                 nir_replace_instr(alu, xform->search, xform->replace,
   20187                                   mem_ctx)) {
   20188                progress = true;
   20189                break;
   20190             }
   20191          }
   20192          break;
   20193       case nir_op_usub_borrow:
   20194          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_usub_borrow_xforms); i++) {
   20195             const struct transform *xform = &nir_opt_algebraic_usub_borrow_xforms[i];
   20196             if (condition_flags[xform->condition_offset] &&
   20197                 nir_replace_instr(alu, xform->search, xform->replace,
   20198                                   mem_ctx)) {
   20199                progress = true;
   20200                break;
   20201             }
   20202          }
   20203          break;
   20204       case nir_op_flog2:
   20205          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_flog2_xforms); i++) {
   20206             const struct transform *xform = &nir_opt_algebraic_flog2_xforms[i];
   20207             if (condition_flags[xform->condition_offset] &&
   20208                 nir_replace_instr(alu, xform->search, xform->replace,
   20209                                   mem_ctx)) {
   20210                progress = true;
   20211                break;
   20212             }
   20213          }
   20214          break;
   20215       case nir_op_inot:
   20216          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_inot_xforms); i++) {
   20217             const struct transform *xform = &nir_opt_algebraic_inot_xforms[i];
   20218             if (condition_flags[xform->condition_offset] &&
   20219                 nir_replace_instr(alu, xform->search, xform->replace,
   20220                                   mem_ctx)) {
   20221                progress = true;
   20222                break;
   20223             }
   20224          }
   20225          break;
   20226       case nir_op_sne:
   20227          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_sne_xforms); i++) {
   20228             const struct transform *xform = &nir_opt_algebraic_sne_xforms[i];
   20229             if (condition_flags[xform->condition_offset] &&
   20230                 nir_replace_instr(alu, xform->search, xform->replace,
   20231                                   mem_ctx)) {
   20232                progress = true;
   20233                break;
   20234             }
   20235          }
   20236          break;
   20237       case nir_op_fmod:
   20238          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fmod_xforms); i++) {
   20239             const struct transform *xform = &nir_opt_algebraic_fmod_xforms[i];
   20240             if (condition_flags[xform->condition_offset] &&
   20241                 nir_replace_instr(alu, xform->search, xform->replace,
   20242                                   mem_ctx)) {
   20243                progress = true;
   20244                break;
   20245             }
   20246          }
   20247          break;
   20248       case nir_op_f2u:
   20249          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_f2u_xforms); i++) {
   20250             const struct transform *xform = &nir_opt_algebraic_f2u_xforms[i];
   20251             if (condition_flags[xform->condition_offset] &&
   20252                 nir_replace_instr(alu, xform->search, xform->replace,
   20253                                   mem_ctx)) {
   20254                progress = true;
   20255                break;
   20256             }
   20257          }
   20258          break;
   20259       case nir_op_fcsel:
   20260          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fcsel_xforms); i++) {
   20261             const struct transform *xform = &nir_opt_algebraic_fcsel_xforms[i];
   20262             if (condition_flags[xform->condition_offset] &&
   20263                 nir_replace_instr(alu, xform->search, xform->replace,
   20264                                   mem_ctx)) {
   20265                progress = true;
   20266                break;
   20267             }
   20268          }
   20269          break;
   20270       case nir_op_isub:
   20271          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_isub_xforms); i++) {
   20272             const struct transform *xform = &nir_opt_algebraic_isub_xforms[i];
   20273             if (condition_flags[xform->condition_offset] &&
   20274                 nir_replace_instr(alu, xform->search, xform->replace,
   20275                                   mem_ctx)) {
   20276                progress = true;
   20277                break;
   20278             }
   20279          }
   20280          break;
   20281       case nir_op_fmax:
   20282          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fmax_xforms); i++) {
   20283             const struct transform *xform = &nir_opt_algebraic_fmax_xforms[i];
   20284             if (condition_flags[xform->condition_offset] &&
   20285                 nir_replace_instr(alu, xform->search, xform->replace,
   20286                                   mem_ctx)) {
   20287                progress = true;
   20288                break;
   20289             }
   20290          }
   20291          break;
   20292       case nir_op_umul_unorm_4x8:
   20293          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_umul_unorm_4x8_xforms); i++) {
   20294             const struct transform *xform = &nir_opt_algebraic_umul_unorm_4x8_xforms[i];
   20295             if (condition_flags[xform->condition_offset] &&
   20296                 nir_replace_instr(alu, xform->search, xform->replace,
   20297                                   mem_ctx)) {
   20298                progress = true;
   20299                break;
   20300             }
   20301          }
   20302          break;
   20303       case nir_op_bitfield_insert:
   20304          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_bitfield_insert_xforms); i++) {
   20305             const struct transform *xform = &nir_opt_algebraic_bitfield_insert_xforms[i];
   20306             if (condition_flags[xform->condition_offset] &&
   20307                 nir_replace_instr(alu, xform->search, xform->replace,
   20308                                   mem_ctx)) {
   20309                progress = true;
   20310                break;
   20311             }
   20312          }
   20313          break;
   20314       case nir_op_feq:
   20315          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_feq_xforms); i++) {
   20316             const struct transform *xform = &nir_opt_algebraic_feq_xforms[i];
   20317             if (condition_flags[xform->condition_offset] &&
   20318                 nir_replace_instr(alu, xform->search, xform->replace,
   20319                                   mem_ctx)) {
   20320                progress = true;
   20321                break;
   20322             }
   20323          }
   20324          break;
   20325       case nir_op_flrp:
   20326          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_flrp_xforms); i++) {
   20327             const struct transform *xform = &nir_opt_algebraic_flrp_xforms[i];
   20328             if (condition_flags[xform->condition_offset] &&
   20329                 nir_replace_instr(alu, xform->search, xform->replace,
   20330                                   mem_ctx)) {
   20331                progress = true;
   20332                break;
   20333             }
   20334          }
   20335          break;
   20336       case nir_op_ior:
   20337          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ior_xforms); i++) {
   20338             const struct transform *xform = &nir_opt_algebraic_ior_xforms[i];
   20339             if (condition_flags[xform->condition_offset] &&
   20340                 nir_replace_instr(alu, xform->search, xform->replace,
   20341                                   mem_ctx)) {
   20342                progress = true;
   20343                break;
   20344             }
   20345          }
   20346          break;
   20347       case nir_op_ussub_4x8:
   20348          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ussub_4x8_xforms); i++) {
   20349             const struct transform *xform = &nir_opt_algebraic_ussub_4x8_xforms[i];
   20350             if (condition_flags[xform->condition_offset] &&
   20351                 nir_replace_instr(alu, xform->search, xform->replace,
   20352                                   mem_ctx)) {
   20353                progress = true;
   20354                break;
   20355             }
   20356          }
   20357          break;
   20358       case nir_op_unpack_snorm_4x8:
   20359          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_unpack_snorm_4x8_xforms); i++) {
   20360             const struct transform *xform = &nir_opt_algebraic_unpack_snorm_4x8_xforms[i];
   20361             if (condition_flags[xform->condition_offset] &&
   20362                 nir_replace_instr(alu, xform->search, xform->replace,
   20363                                   mem_ctx)) {
   20364                progress = true;
   20365                break;
   20366             }
   20367          }
   20368          break;
   20369       case nir_op_frem:
   20370          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_frem_xforms); i++) {
   20371             const struct transform *xform = &nir_opt_algebraic_frem_xforms[i];
   20372             if (condition_flags[xform->condition_offset] &&
   20373                 nir_replace_instr(alu, xform->search, xform->replace,
   20374                                   mem_ctx)) {
   20375                progress = true;
   20376                break;
   20377             }
   20378          }
   20379          break;
   20380       case nir_op_unpack_unorm_2x16:
   20381          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_unpack_unorm_2x16_xforms); i++) {
   20382             const struct transform *xform = &nir_opt_algebraic_unpack_unorm_2x16_xforms[i];
   20383             if (condition_flags[xform->condition_offset] &&
   20384                 nir_replace_instr(alu, xform->search, xform->replace,
   20385                                   mem_ctx)) {
   20386                progress = true;
   20387                break;
   20388             }
   20389          }
   20390          break;
   20391       case nir_op_unpack_snorm_2x16:
   20392          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_unpack_snorm_2x16_xforms); i++) {
   20393             const struct transform *xform = &nir_opt_algebraic_unpack_snorm_2x16_xforms[i];
   20394             if (condition_flags[xform->condition_offset] &&
   20395                 nir_replace_instr(alu, xform->search, xform->replace,
   20396                                   mem_ctx)) {
   20397                progress = true;
   20398                break;
   20399             }
   20400          }
   20401          break;
   20402       case nir_op_imax:
   20403          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_imax_xforms); i++) {
   20404             const struct transform *xform = &nir_opt_algebraic_imax_xforms[i];
   20405             if (condition_flags[xform->condition_offset] &&
   20406                 nir_replace_instr(alu, xform->search, xform->replace,
   20407                                   mem_ctx)) {
   20408                progress = true;
   20409                break;
   20410             }
   20411          }
   20412          break;
   20413       case nir_op_fsat:
   20414          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fsat_xforms); i++) {
   20415             const struct transform *xform = &nir_opt_algebraic_fsat_xforms[i];
   20416             if (condition_flags[xform->condition_offset] &&
   20417                 nir_replace_instr(alu, xform->search, xform->replace,
   20418                                   mem_ctx)) {
   20419                progress = true;
   20420                break;
   20421             }
   20422          }
   20423          break;
   20424       case nir_op_extract_u16:
   20425          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_extract_u16_xforms); i++) {
   20426             const struct transform *xform = &nir_opt_algebraic_extract_u16_xforms[i];
   20427             if (condition_flags[xform->condition_offset] &&
   20428                 nir_replace_instr(alu, xform->search, xform->replace,
   20429                                   mem_ctx)) {
   20430                progress = true;
   20431                break;
   20432             }
   20433          }
   20434          break;
   20435       case nir_op_fge:
   20436          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fge_xforms); i++) {
   20437             const struct transform *xform = &nir_opt_algebraic_fge_xforms[i];
   20438             if (condition_flags[xform->condition_offset] &&
   20439                 nir_replace_instr(alu, xform->search, xform->replace,
   20440                                   mem_ctx)) {
   20441                progress = true;
   20442                break;
   20443             }
   20444          }
   20445          break;
   20446       case nir_op_frcp:
   20447          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_frcp_xforms); i++) {
   20448             const struct transform *xform = &nir_opt_algebraic_frcp_xforms[i];
   20449             if (condition_flags[xform->condition_offset] &&
   20450                 nir_replace_instr(alu, xform->search, xform->replace,
   20451                                   mem_ctx)) {
   20452                progress = true;
   20453                break;
   20454             }
   20455          }
   20456          break;
   20457       case nir_op_fxor:
   20458          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fxor_xforms); i++) {
   20459             const struct transform *xform = &nir_opt_algebraic_fxor_xforms[i];
   20460             if (condition_flags[xform->condition_offset] &&
   20461                 nir_replace_instr(alu, xform->search, xform->replace,
   20462                                   mem_ctx)) {
   20463                progress = true;
   20464                break;
   20465             }
   20466          }
   20467          break;
   20468       case nir_op_ushr:
   20469          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ushr_xforms); i++) {
   20470             const struct transform *xform = &nir_opt_algebraic_ushr_xforms[i];
   20471             if (condition_flags[xform->condition_offset] &&
   20472                 nir_replace_instr(alu, xform->search, xform->replace,
   20473                                   mem_ctx)) {
   20474                progress = true;
   20475                break;
   20476             }
   20477          }
   20478          break;
   20479       case nir_op_fexp2:
   20480          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fexp2_xforms); i++) {
   20481             const struct transform *xform = &nir_opt_algebraic_fexp2_xforms[i];
   20482             if (condition_flags[xform->condition_offset] &&
   20483                 nir_replace_instr(alu, xform->search, xform->replace,
   20484                                   mem_ctx)) {
   20485                progress = true;
   20486                break;
   20487             }
   20488          }
   20489          break;
   20490       case nir_op_ishr:
   20491          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ishr_xforms); i++) {
   20492             const struct transform *xform = &nir_opt_algebraic_ishr_xforms[i];
   20493             if (condition_flags[xform->condition_offset] &&
   20494                 nir_replace_instr(alu, xform->search, xform->replace,
   20495                                   mem_ctx)) {
   20496                progress = true;
   20497                break;
   20498             }
   20499          }
   20500          break;
   20501       case nir_op_slt:
   20502          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_slt_xforms); i++) {
   20503             const struct transform *xform = &nir_opt_algebraic_slt_xforms[i];
   20504             if (condition_flags[xform->condition_offset] &&
   20505                 nir_replace_instr(alu, xform->search, xform->replace,
   20506                                   mem_ctx)) {
   20507                progress = true;
   20508                break;
   20509             }
   20510          }
   20511          break;
   20512       case nir_op_f2i:
   20513          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_f2i_xforms); i++) {
   20514             const struct transform *xform = &nir_opt_algebraic_f2i_xforms[i];
   20515             if (condition_flags[xform->condition_offset] &&
   20516                 nir_replace_instr(alu, xform->search, xform->replace,
   20517                                   mem_ctx)) {
   20518                progress = true;
   20519                break;
   20520             }
   20521          }
   20522          break;
   20523       case nir_op_flt:
   20524          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_flt_xforms); i++) {
   20525             const struct transform *xform = &nir_opt_algebraic_flt_xforms[i];
   20526             if (condition_flags[xform->condition_offset] &&
   20527                 nir_replace_instr(alu, xform->search, xform->replace,
   20528                                   mem_ctx)) {
   20529                progress = true;
   20530                break;
   20531             }
   20532          }
   20533          break;
   20534       case nir_op_ult:
   20535          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ult_xforms); i++) {
   20536             const struct transform *xform = &nir_opt_algebraic_ult_xforms[i];
   20537             if (condition_flags[xform->condition_offset] &&
   20538                 nir_replace_instr(alu, xform->search, xform->replace,
   20539                                   mem_ctx)) {
   20540                progress = true;
   20541                break;
   20542             }
   20543          }
   20544          break;
   20545       case nir_op_fsub:
   20546          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fsub_xforms); i++) {
   20547             const struct transform *xform = &nir_opt_algebraic_fsub_xforms[i];
   20548             if (condition_flags[xform->condition_offset] &&
   20549                 nir_replace_instr(alu, xform->search, xform->replace,
   20550                                   mem_ctx)) {
   20551                progress = true;
   20552                break;
   20553             }
   20554          }
   20555          break;
   20556       case nir_op_fneg:
   20557          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fneg_xforms); i++) {
   20558             const struct transform *xform = &nir_opt_algebraic_fneg_xforms[i];
   20559             if (condition_flags[xform->condition_offset] &&
   20560                 nir_replace_instr(alu, xform->search, xform->replace,
   20561                                   mem_ctx)) {
   20562                progress = true;
   20563                break;
   20564             }
   20565          }
   20566          break;
   20567       case nir_op_fne:
   20568          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fne_xforms); i++) {
   20569             const struct transform *xform = &nir_opt_algebraic_fne_xforms[i];
   20570             if (condition_flags[xform->condition_offset] &&
   20571                 nir_replace_instr(alu, xform->search, xform->replace,
   20572                                   mem_ctx)) {
   20573                progress = true;
   20574                break;
   20575             }
   20576          }
   20577          break;
   20578       case nir_op_iabs:
   20579          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_iabs_xforms); i++) {
   20580             const struct transform *xform = &nir_opt_algebraic_iabs_xforms[i];
   20581             if (condition_flags[xform->condition_offset] &&
   20582                 nir_replace_instr(alu, xform->search, xform->replace,
   20583                                   mem_ctx)) {
   20584                progress = true;
   20585                break;
   20586             }
   20587          }
   20588          break;
   20589       case nir_op_unpack_unorm_4x8:
   20590          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_unpack_unorm_4x8_xforms); i++) {
   20591             const struct transform *xform = &nir_opt_algebraic_unpack_unorm_4x8_xforms[i];
   20592             if (condition_flags[xform->condition_offset] &&
   20593                 nir_replace_instr(alu, xform->search, xform->replace,
   20594                                   mem_ctx)) {
   20595                progress = true;
   20596                break;
   20597             }
   20598          }
   20599          break;
   20600       case nir_op_fmin:
   20601          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_fmin_xforms); i++) {
   20602             const struct transform *xform = &nir_opt_algebraic_fmin_xforms[i];
   20603             if (condition_flags[xform->condition_offset] &&
   20604                 nir_replace_instr(alu, xform->search, xform->replace,
   20605                                   mem_ctx)) {
   20606                progress = true;
   20607                break;
   20608             }
   20609          }
   20610          break;
   20611       case nir_op_ine:
   20612          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ine_xforms); i++) {
   20613             const struct transform *xform = &nir_opt_algebraic_ine_xforms[i];
   20614             if (condition_flags[xform->condition_offset] &&
   20615                 nir_replace_instr(alu, xform->search, xform->replace,
   20616                                   mem_ctx)) {
   20617                progress = true;
   20618                break;
   20619             }
   20620          }
   20621          break;
   20622       case nir_op_udiv:
   20623          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_udiv_xforms); i++) {
   20624             const struct transform *xform = &nir_opt_algebraic_udiv_xforms[i];
   20625             if (condition_flags[xform->condition_offset] &&
   20626                 nir_replace_instr(alu, xform->search, xform->replace,
   20627                                   mem_ctx)) {
   20628                progress = true;
   20629                break;
   20630             }
   20631          }
   20632          break;
   20633       case nir_op_extract_i8:
   20634          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_extract_i8_xforms); i++) {
   20635             const struct transform *xform = &nir_opt_algebraic_extract_i8_xforms[i];
   20636             if (condition_flags[xform->condition_offset] &&
   20637                 nir_replace_instr(alu, xform->search, xform->replace,
   20638                                   mem_ctx)) {
   20639                progress = true;
   20640                break;
   20641             }
   20642          }
   20643          break;
   20644       case nir_op_uadd_carry:
   20645          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_uadd_carry_xforms); i++) {
   20646             const struct transform *xform = &nir_opt_algebraic_uadd_carry_xforms[i];
   20647             if (condition_flags[xform->condition_offset] &&
   20648                 nir_replace_instr(alu, xform->search, xform->replace,
   20649                                   mem_ctx)) {
   20650                progress = true;
   20651                break;
   20652             }
   20653          }
   20654          break;
   20655       case nir_op_ibitfield_extract:
   20656          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ibitfield_extract_xforms); i++) {
   20657             const struct transform *xform = &nir_opt_algebraic_ibitfield_extract_xforms[i];
   20658             if (condition_flags[xform->condition_offset] &&
   20659                 nir_replace_instr(alu, xform->search, xform->replace,
   20660                                   mem_ctx)) {
   20661                progress = true;
   20662                break;
   20663             }
   20664          }
   20665          break;
   20666       case nir_op_ldexp:
   20667          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_ldexp_xforms); i++) {
   20668             const struct transform *xform = &nir_opt_algebraic_ldexp_xforms[i];
   20669             if (condition_flags[xform->condition_offset] &&
   20670                 nir_replace_instr(alu, xform->search, xform->replace,
   20671                                   mem_ctx)) {
   20672                progress = true;
   20673                break;
   20674             }
   20675          }
   20676          break;
   20677       case nir_op_extract_i16:
   20678          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_extract_i16_xforms); i++) {
   20679             const struct transform *xform = &nir_opt_algebraic_extract_i16_xforms[i];
   20680             if (condition_flags[xform->condition_offset] &&
   20681                 nir_replace_instr(alu, xform->search, xform->replace,
   20682                                   mem_ctx)) {
   20683                progress = true;
   20684                break;
   20685             }
   20686          }
   20687          break;
   20688       default:
   20689          break;
   20690       }
   20691    }
   20692 
   20693    return progress;
   20694 }
   20695 
   20696 static bool
   20697 nir_opt_algebraic_impl(nir_function_impl *impl, const bool *condition_flags)
   20698 {
   20699    void *mem_ctx = ralloc_parent(impl);
   20700    bool progress = false;
   20701 
   20702    nir_foreach_block_reverse(block, impl) {
   20703       progress |= nir_opt_algebraic_block(block, condition_flags, mem_ctx);
   20704    }
   20705 
   20706    if (progress)
   20707       nir_metadata_preserve(impl, nir_metadata_block_index |
   20708                                   nir_metadata_dominance);
   20709 
   20710    return progress;
   20711 }
   20712 
   20713 
   20714 bool
   20715 nir_opt_algebraic(nir_shader *shader)
   20716 {
   20717    bool progress = false;
   20718    bool condition_flags[37];
   20719    const nir_shader_compiler_options *options = shader->options;
   20720    (void) options;
   20721 
   20722    condition_flags[0] = true;
   20723    condition_flags[1] = options->lower_idiv;
   20724    condition_flags[2] = options->lower_flrp32;
   20725    condition_flags[3] = options->lower_flrp64;
   20726    condition_flags[4] = options->lower_ffract;
   20727    condition_flags[5] = !options->lower_flrp32;
   20728    condition_flags[6] = !options->lower_flrp64;
   20729    condition_flags[7] = options->lower_ffma;
   20730    condition_flags[8] = options->fuse_ffma;
   20731    condition_flags[9] = !options->lower_fsat;
   20732    condition_flags[10] = options->lower_fsat;
   20733    condition_flags[11] = options->lower_scmp;
   20734    condition_flags[12] = options->lower_fpow;
   20735    condition_flags[13] = !options->lower_fpow;
   20736    condition_flags[14] = options->lower_fdiv;
   20737    condition_flags[15] = options->lower_fsqrt;
   20738    condition_flags[16] = !options->lower_fsqrt;
   20739    condition_flags[17] = !options->lower_extract_byte;
   20740    condition_flags[18] = !options->lower_extract_word;
   20741    condition_flags[19] = options->lower_sub;
   20742    condition_flags[20] = options->lower_negate;
   20743    condition_flags[21] = options->lower_fmod32;
   20744    condition_flags[22] = options->lower_fmod64;
   20745    condition_flags[23] = options->lower_uadd_carry;
   20746    condition_flags[24] = options->lower_usub_borrow;
   20747    condition_flags[25] = options->lower_bitfield_insert;
   20748    condition_flags[26] = options->lower_bitfield_extract;
   20749    condition_flags[27] = options->lower_extract_byte;
   20750    condition_flags[28] = options->lower_extract_word;
   20751    condition_flags[29] = options->lower_pack_unorm_2x16;
   20752    condition_flags[30] = options->lower_pack_unorm_4x8;
   20753    condition_flags[31] = options->lower_pack_snorm_2x16;
   20754    condition_flags[32] = options->lower_pack_snorm_4x8;
   20755    condition_flags[33] = options->lower_unpack_unorm_2x16;
   20756    condition_flags[34] = options->lower_unpack_unorm_4x8;
   20757    condition_flags[35] = options->lower_unpack_snorm_2x16;
   20758    condition_flags[36] = options->lower_unpack_snorm_4x8;
   20759 
   20760    nir_foreach_function(function, shader) {
   20761       if (function->impl)
   20762          progress |= nir_opt_algebraic_impl(function->impl, condition_flags);
   20763    }
   20764 
   20765    return progress;
   20766 }
   20767 
   20768 
   20769 #include "nir.h"
   20770 #include "nir_search.h"
   20771 
   20772 #ifndef NIR_OPT_ALGEBRAIC_STRUCT_DEFS
   20773 #define NIR_OPT_ALGEBRAIC_STRUCT_DEFS
   20774 
   20775 struct transform {
   20776    const nir_search_expression *search;
   20777    const nir_search_value *replace;
   20778    unsigned condition_offset;
   20779 };
   20780 
   20781 #endif
   20782 
   20783 
   20784 #include "compiler/nir/nir_search_helpers.h"
   20785 static const nir_search_variable search270_0_0 = {
   20786    { nir_search_value_variable, 0 },
   20787    0, /* a */
   20788    false,
   20789    nir_type_invalid,
   20790    NULL,
   20791 };
   20792 #include "compiler/nir/nir_search_helpers.h"
   20793 static const nir_search_expression search270_0 = {
   20794    { nir_search_value_expression, 0 },
   20795    false,
   20796    nir_op_inot,
   20797    { &search270_0_0.value },
   20798    NULL,
   20799 };
   20800 #include "compiler/nir/nir_search_helpers.h"
   20801 static const nir_search_expression search270 = {
   20802    { nir_search_value_expression, 0 },
   20803    false,
   20804    nir_op_b2f,
   20805    { &search270_0.value },
   20806    (is_used_more_than_once),
   20807 };
   20808 
   20809 #include "compiler/nir/nir_search_helpers.h"
   20810 static const nir_search_variable replace270_0 = {
   20811    { nir_search_value_variable, 0 },
   20812    0, /* a */
   20813    false,
   20814    nir_type_invalid,
   20815    NULL,
   20816 };
   20817 
   20818 #include "compiler/nir/nir_search_helpers.h"
   20819 static const nir_search_constant replace270_1 = {
   20820    { nir_search_value_constant, 0 },
   20821    nir_type_float, { 0x0 /* 0.0 */ },
   20822 };
   20823 
   20824 #include "compiler/nir/nir_search_helpers.h"
   20825 static const nir_search_constant replace270_2 = {
   20826    { nir_search_value_constant, 0 },
   20827    nir_type_float, { 0x3ff0000000000000 /* 1.0 */ },
   20828 };
   20829 #include "compiler/nir/nir_search_helpers.h"
   20830 static const nir_search_expression replace270 = {
   20831    { nir_search_value_expression, 0 },
   20832    false,
   20833    nir_op_bcsel,
   20834    { &replace270_0.value, &replace270_1.value, &replace270_2.value },
   20835    NULL,
   20836 };
   20837 
   20838 static const struct transform nir_opt_algebraic_late_b2f_xforms[] = {
   20839    { &search270, &replace270.value, 0 },
   20840 };
   20841 
   20842 #include "compiler/nir/nir_search_helpers.h"
   20843 static const nir_search_variable search268_0 = {
   20844    { nir_search_value_variable, 0 },
   20845    0, /* a */
   20846    false,
   20847    nir_type_invalid,
   20848    NULL,
   20849 };
   20850 
   20851 #include "compiler/nir/nir_search_helpers.h"
   20852 static const nir_search_variable search268_1 = {
   20853    { nir_search_value_variable, 0 },
   20854    1, /* b */
   20855    false,
   20856    nir_type_invalid,
   20857    NULL,
   20858 };
   20859 #include "compiler/nir/nir_search_helpers.h"
   20860 static const nir_search_expression search268 = {
   20861    { nir_search_value_expression, 0 },
   20862    false,
   20863    nir_op_fdot4,
   20864    { &search268_0.value, &search268_1.value },
   20865    NULL,
   20866 };
   20867 
   20868 #include "compiler/nir/nir_search_helpers.h"
   20869 static const nir_search_variable replace268_0 = {
   20870    { nir_search_value_variable, 0 },
   20871    0, /* a */
   20872    false,
   20873    nir_type_invalid,
   20874    NULL,
   20875 };
   20876 
   20877 #include "compiler/nir/nir_search_helpers.h"
   20878 static const nir_search_variable replace268_1 = {
   20879    { nir_search_value_variable, 0 },
   20880    1, /* b */
   20881    false,
   20882    nir_type_invalid,
   20883    NULL,
   20884 };
   20885 #include "compiler/nir/nir_search_helpers.h"
   20886 static const nir_search_expression replace268 = {
   20887    { nir_search_value_expression, 0 },
   20888    false,
   20889    nir_op_fdot_replicated4,
   20890    { &replace268_0.value, &replace268_1.value },
   20891    NULL,
   20892 };
   20893 
   20894 static const struct transform nir_opt_algebraic_late_fdot4_xforms[] = {
   20895    { &search268, &replace268.value, 37 },
   20896 };
   20897 
   20898 #include "compiler/nir/nir_search_helpers.h"
   20899 static const nir_search_variable search262_0_0 = {
   20900    { nir_search_value_variable, 0 },
   20901    0, /* a */
   20902    false,
   20903    nir_type_invalid,
   20904    NULL,
   20905 };
   20906 
   20907 #include "compiler/nir/nir_search_helpers.h"
   20908 static const nir_search_variable search262_0_1 = {
   20909    { nir_search_value_variable, 0 },
   20910    1, /* b */
   20911    false,
   20912    nir_type_invalid,
   20913    NULL,
   20914 };
   20915 #include "compiler/nir/nir_search_helpers.h"
   20916 static const nir_search_expression search262_0 = {
   20917    { nir_search_value_expression, 0 },
   20918    false,
   20919    nir_op_fadd,
   20920    { &search262_0_0.value, &search262_0_1.value },
   20921    NULL,
   20922 };
   20923 
   20924 #include "compiler/nir/nir_search_helpers.h"
   20925 static const nir_search_constant search262_1 = {
   20926    { nir_search_value_constant, 0 },
   20927    nir_type_float, { 0x0 /* 0.0 */ },
   20928 };
   20929 #include "compiler/nir/nir_search_helpers.h"
   20930 static const nir_search_expression search262 = {
   20931    { nir_search_value_expression, 0 },
   20932    false,
   20933    nir_op_flt,
   20934    { &search262_0.value, &search262_1.value },
   20935    NULL,
   20936 };
   20937 
   20938 #include "compiler/nir/nir_search_helpers.h"
   20939 static const nir_search_variable replace262_0 = {
   20940    { nir_search_value_variable, 0 },
   20941    0, /* a */
   20942    false,
   20943    nir_type_invalid,
   20944    NULL,
   20945 };
   20946 
   20947 #include "compiler/nir/nir_search_helpers.h"
   20948 static const nir_search_variable replace262_1_0 = {
   20949    { nir_search_value_variable, 0 },
   20950    1, /* b */
   20951    false,
   20952    nir_type_invalid,
   20953    NULL,
   20954 };
   20955 #include "compiler/nir/nir_search_helpers.h"
   20956 static const nir_search_expression replace262_1 = {
   20957    { nir_search_value_expression, 0 },
   20958    false,
   20959    nir_op_fneg,
   20960    { &replace262_1_0.value },
   20961    NULL,
   20962 };
   20963 #include "compiler/nir/nir_search_helpers.h"
   20964 static const nir_search_expression replace262 = {
   20965    { nir_search_value_expression, 0 },
   20966    false,
   20967    nir_op_flt,
   20968    { &replace262_0.value, &replace262_1.value },
   20969    NULL,
   20970 };
   20971 
   20972 static const struct transform nir_opt_algebraic_late_flt_xforms[] = {
   20973    { &search262, &replace262.value, 0 },
   20974 };
   20975 
   20976 #include "compiler/nir/nir_search_helpers.h"
   20977 static const nir_search_variable search266_0 = {
   20978    { nir_search_value_variable, 0 },
   20979    0, /* a */
   20980    false,
   20981    nir_type_invalid,
   20982    NULL,
   20983 };
   20984 
   20985 #include "compiler/nir/nir_search_helpers.h"
   20986 static const nir_search_variable search266_1 = {
   20987    { nir_search_value_variable, 0 },
   20988    1, /* b */
   20989    false,
   20990    nir_type_invalid,
   20991    NULL,
   20992 };
   20993 #include "compiler/nir/nir_search_helpers.h"
   20994 static const nir_search_expression search266 = {
   20995    { nir_search_value_expression, 0 },
   20996    false,
   20997    nir_op_fdot2,
   20998    { &search266_0.value, &search266_1.value },
   20999    NULL,
   21000 };
   21001 
   21002 #include "compiler/nir/nir_search_helpers.h"
   21003 static const nir_search_variable replace266_0 = {
   21004    { nir_search_value_variable, 0 },
   21005    0, /* a */
   21006    false,
   21007    nir_type_invalid,
   21008    NULL,
   21009 };
   21010 
   21011 #include "compiler/nir/nir_search_helpers.h"
   21012 static const nir_search_variable replace266_1 = {
   21013    { nir_search_value_variable, 0 },
   21014    1, /* b */
   21015    false,
   21016    nir_type_invalid,
   21017    NULL,
   21018 };
   21019 #include "compiler/nir/nir_search_helpers.h"
   21020 static const nir_search_expression replace266 = {
   21021    { nir_search_value_expression, 0 },
   21022    false,
   21023    nir_op_fdot_replicated2,
   21024    { &replace266_0.value, &replace266_1.value },
   21025    NULL,
   21026 };
   21027 
   21028 static const struct transform nir_opt_algebraic_late_fdot2_xforms[] = {
   21029    { &search266, &replace266.value, 37 },
   21030 };
   21031 
   21032 #include "compiler/nir/nir_search_helpers.h"
   21033 static const nir_search_variable search267_0 = {
   21034    { nir_search_value_variable, 0 },
   21035    0, /* a */
   21036    false,
   21037    nir_type_invalid,
   21038    NULL,
   21039 };
   21040 
   21041 #include "compiler/nir/nir_search_helpers.h"
   21042 static const nir_search_variable search267_1 = {
   21043    { nir_search_value_variable, 0 },
   21044    1, /* b */
   21045    false,
   21046    nir_type_invalid,
   21047    NULL,
   21048 };
   21049 #include "compiler/nir/nir_search_helpers.h"
   21050 static const nir_search_expression search267 = {
   21051    { nir_search_value_expression, 0 },
   21052    false,
   21053    nir_op_fdot3,
   21054    { &search267_0.value, &search267_1.value },
   21055    NULL,
   21056 };
   21057 
   21058 #include "compiler/nir/nir_search_helpers.h"
   21059 static const nir_search_variable replace267_0 = {
   21060    { nir_search_value_variable, 0 },
   21061    0, /* a */
   21062    false,
   21063    nir_type_invalid,
   21064    NULL,
   21065 };
   21066 
   21067 #include "compiler/nir/nir_search_helpers.h"
   21068 static const nir_search_variable replace267_1 = {
   21069    { nir_search_value_variable, 0 },
   21070    1, /* b */
   21071    false,
   21072    nir_type_invalid,
   21073    NULL,
   21074 };
   21075 #include "compiler/nir/nir_search_helpers.h"
   21076 static const nir_search_expression replace267 = {
   21077    { nir_search_value_expression, 0 },
   21078    false,
   21079    nir_op_fdot_replicated3,
   21080    { &replace267_0.value, &replace267_1.value },
   21081    NULL,
   21082 };
   21083 
   21084 static const struct transform nir_opt_algebraic_late_fdot3_xforms[] = {
   21085    { &search267, &replace267.value, 37 },
   21086 };
   21087 
   21088 #include "compiler/nir/nir_search_helpers.h"
   21089 static const nir_search_variable search271_0_0_0 = {
   21090    { nir_search_value_variable, 0 },
   21091    0, /* a */
   21092    false,
   21093    nir_type_invalid,
   21094    NULL,
   21095 };
   21096 #include "compiler/nir/nir_search_helpers.h"
   21097 static const nir_search_expression search271_0_0 = {
   21098    { nir_search_value_expression, 0 },
   21099    false,
   21100    nir_op_inot,
   21101    { &search271_0_0_0.value },
   21102    NULL,
   21103 };
   21104 #include "compiler/nir/nir_search_helpers.h"
   21105 static const nir_search_expression search271_0 = {
   21106    { nir_search_value_expression, 0 },
   21107    false,
   21108    nir_op_b2f,
   21109    { &search271_0_0.value },
   21110    NULL,
   21111 };
   21112 #include "compiler/nir/nir_search_helpers.h"
   21113 static const nir_search_expression search271 = {
   21114    { nir_search_value_expression, 0 },
   21115    false,
   21116    nir_op_fneg,
   21117    { &search271_0.value },
   21118    (is_used_more_than_once),
   21119 };
   21120 
   21121 #include "compiler/nir/nir_search_helpers.h"
   21122 static const nir_search_variable replace271_0 = {
   21123    { nir_search_value_variable, 0 },
   21124    0, /* a */
   21125    false,
   21126    nir_type_invalid,
   21127    NULL,
   21128 };
   21129 
   21130 #include "compiler/nir/nir_search_helpers.h"
   21131 static const nir_search_constant replace271_1 = {
   21132    { nir_search_value_constant, 0 },
   21133    nir_type_float, { 0x8000000000000000L /* -0.0 */ },
   21134 };
   21135 
   21136 #include "compiler/nir/nir_search_helpers.h"
   21137 static const nir_search_constant replace271_2 = {
   21138    { nir_search_value_constant, 0 },
   21139    nir_type_float, { 0xbff0000000000000L /* -1.0 */ },
   21140 };
   21141 #include "compiler/nir/nir_search_helpers.h"
   21142 static const nir_search_expression replace271 = {
   21143    { nir_search_value_expression, 0 },
   21144    false,
   21145    nir_op_bcsel,
   21146    { &replace271_0.value, &replace271_1.value, &replace271_2.value },
   21147    NULL,
   21148 };
   21149 
   21150 static const struct transform nir_opt_algebraic_late_fneg_xforms[] = {
   21151    { &search271, &replace271.value, 0 },
   21152 };
   21153 
   21154 #include "compiler/nir/nir_search_helpers.h"
   21155 static const nir_search_variable search273_0_0 = {
   21156    { nir_search_value_variable, 0 },
   21157    0, /* c */
   21158    true,
   21159    nir_type_invalid,
   21160    NULL,
   21161 };
   21162 
   21163 #include "compiler/nir/nir_search_helpers.h"
   21164 static const nir_search_variable search273_0_1 = {
   21165    { nir_search_value_variable, 0 },
   21166    1, /* a */
   21167    false,
   21168    nir_type_invalid,
   21169    NULL,
   21170 };
   21171 #include "compiler/nir/nir_search_helpers.h"
   21172 static const nir_search_expression search273_0 = {
   21173    { nir_search_value_expression, 0 },
   21174    false,
   21175    nir_op_fadd,
   21176    { &search273_0_0.value, &search273_0_1.value },
   21177    (is_used_once),
   21178 };
   21179 
   21180 #include "compiler/nir/nir_search_helpers.h"
   21181 static const nir_search_variable search273_1_0 = {
   21182    { nir_search_value_variable, 0 },
   21183    0, /* c */
   21184    true,
   21185    nir_type_invalid,
   21186    NULL,
   21187 };
   21188 
   21189 #include "compiler/nir/nir_search_helpers.h"
   21190 static const nir_search_variable search273_1_1 = {
   21191    { nir_search_value_variable, 0 },
   21192    2, /* b */
   21193    false,
   21194    nir_type_invalid,
   21195    NULL,
   21196 };
   21197 #include "compiler/nir/nir_search_helpers.h"
   21198 static const nir_search_expression search273_1 = {
   21199    { nir_search_value_expression, 0 },
   21200    false,
   21201    nir_op_fadd,
   21202    { &search273_1_0.value, &search273_1_1.value },
   21203    (is_used_once),
   21204 };
   21205 #include "compiler/nir/nir_search_helpers.h"
   21206 static const nir_search_expression search273 = {
   21207    { nir_search_value_expression, 0 },
   21208    false,
   21209    nir_op_fmax,
   21210    { &search273_0.value, &search273_1.value },
   21211    NULL,
   21212 };
   21213 
   21214 #include "compiler/nir/nir_search_helpers.h"
   21215 static const nir_search_variable replace273_0 = {
   21216    { nir_search_value_variable, 0 },
   21217    0, /* c */
   21218    false,
   21219    nir_type_invalid,
   21220    NULL,
   21221 };
   21222 
   21223 #include "compiler/nir/nir_search_helpers.h"
   21224 static const nir_search_variable replace273_1_0 = {
   21225    { nir_search_value_variable, 0 },
   21226    1, /* a */
   21227    false,
   21228    nir_type_invalid,
   21229    NULL,
   21230 };
   21231 
   21232 #include "compiler/nir/nir_search_helpers.h"
   21233 static const nir_search_variable replace273_1_1 = {
   21234    { nir_search_value_variable, 0 },
   21235    2, /* b */
   21236    false,
   21237    nir_type_invalid,
   21238    NULL,
   21239 };
   21240 #include "compiler/nir/nir_search_helpers.h"
   21241 static const nir_search_expression replace273_1 = {
   21242    { nir_search_value_expression, 0 },
   21243    false,
   21244    nir_op_fmax,
   21245    { &replace273_1_0.value, &replace273_1_1.value },
   21246    NULL,
   21247 };
   21248 #include "compiler/nir/nir_search_helpers.h"
   21249 static const nir_search_expression replace273 = {
   21250    { nir_search_value_expression, 0 },
   21251    false,
   21252    nir_op_fadd,
   21253    { &replace273_0.value, &replace273_1.value },
   21254    NULL,
   21255 };
   21256 
   21257 static const struct transform nir_opt_algebraic_late_fmax_xforms[] = {
   21258    { &search273, &replace273.value, 0 },
   21259 };
   21260 
   21261 #include "compiler/nir/nir_search_helpers.h"
   21262 static const nir_search_variable search265_0_0 = {
   21263    { nir_search_value_variable, 0 },
   21264    0, /* a */
   21265    false,
   21266    nir_type_invalid,
   21267    NULL,
   21268 };
   21269 
   21270 #include "compiler/nir/nir_search_helpers.h"
   21271 static const nir_search_variable search265_0_1 = {
   21272    { nir_search_value_variable, 0 },
   21273    1, /* b */
   21274    false,
   21275    nir_type_invalid,
   21276    NULL,
   21277 };
   21278 #include "compiler/nir/nir_search_helpers.h"
   21279 static const nir_search_expression search265_0 = {
   21280    { nir_search_value_expression, 0 },
   21281    false,
   21282    nir_op_fadd,
   21283    { &search265_0_0.value, &search265_0_1.value },
   21284    NULL,
   21285 };
   21286 
   21287 #include "compiler/nir/nir_search_helpers.h"
   21288 static const nir_search_constant search265_1 = {
   21289    { nir_search_value_constant, 0 },
   21290    nir_type_float, { 0x0 /* 0.0 */ },
   21291 };
   21292 #include "compiler/nir/nir_search_helpers.h"
   21293 static const nir_search_expression search265 = {
   21294    { nir_search_value_expression, 0 },
   21295    true,
   21296    nir_op_fne,
   21297    { &search265_0.value, &search265_1.value },
   21298    NULL,
   21299 };
   21300 
   21301 #include "compiler/nir/nir_search_helpers.h"
   21302 static const nir_search_variable replace265_0 = {
   21303    { nir_search_value_variable, 0 },
   21304    0, /* a */
   21305    false,
   21306    nir_type_invalid,
   21307    NULL,
   21308 };
   21309 
   21310 #include "compiler/nir/nir_search_helpers.h"
   21311 static const nir_search_variable replace265_1_0 = {
   21312    { nir_search_value_variable, 0 },
   21313    1, /* b */
   21314    false,
   21315    nir_type_invalid,
   21316    NULL,
   21317 };
   21318 #include "compiler/nir/nir_search_helpers.h"
   21319 static const nir_search_expression replace265_1 = {
   21320    { nir_search_value_expression, 0 },
   21321    false,
   21322    nir_op_fneg,
   21323    { &replace265_1_0.value },
   21324    NULL,
   21325 };
   21326 #include "compiler/nir/nir_search_helpers.h"
   21327 static const nir_search_expression replace265 = {
   21328    { nir_search_value_expression, 0 },
   21329    false,
   21330    nir_op_fne,
   21331    { &replace265_0.value, &replace265_1.value },
   21332    NULL,
   21333 };
   21334 
   21335 static const struct transform nir_opt_algebraic_late_fne_xforms[] = {
   21336    { &search265, &replace265.value, 0 },
   21337 };
   21338 
   21339 #include "compiler/nir/nir_search_helpers.h"
   21340 static const nir_search_variable search272_0_0 = {
   21341    { nir_search_value_variable, 0 },
   21342    0, /* c */
   21343    true,
   21344    nir_type_invalid,
   21345    NULL,
   21346 };
   21347 
   21348 #include "compiler/nir/nir_search_helpers.h"
   21349 static const nir_search_variable search272_0_1 = {
   21350    { nir_search_value_variable, 0 },
   21351    1, /* a */
   21352    false,
   21353    nir_type_invalid,
   21354    NULL,
   21355 };
   21356 #include "compiler/nir/nir_search_helpers.h"
   21357 static const nir_search_expression search272_0 = {
   21358    { nir_search_value_expression, 0 },
   21359    false,
   21360    nir_op_fadd,
   21361    { &search272_0_0.value, &search272_0_1.value },
   21362    (is_used_once),
   21363 };
   21364 
   21365 #include "compiler/nir/nir_search_helpers.h"
   21366 static const nir_search_variable search272_1_0 = {
   21367    { nir_search_value_variable, 0 },
   21368    0, /* c */
   21369    true,
   21370    nir_type_invalid,
   21371    NULL,
   21372 };
   21373 
   21374 #include "compiler/nir/nir_search_helpers.h"
   21375 static const nir_search_variable search272_1_1 = {
   21376    { nir_search_value_variable, 0 },
   21377    2, /* b */
   21378    false,
   21379    nir_type_invalid,
   21380    NULL,
   21381 };
   21382 #include "compiler/nir/nir_search_helpers.h"
   21383 static const nir_search_expression search272_1 = {
   21384    { nir_search_value_expression, 0 },
   21385    false,
   21386    nir_op_fadd,
   21387    { &search272_1_0.value, &search272_1_1.value },
   21388    (is_used_once),
   21389 };
   21390 #include "compiler/nir/nir_search_helpers.h"
   21391 static const nir_search_expression search272 = {
   21392    { nir_search_value_expression, 0 },
   21393    false,
   21394    nir_op_fmin,
   21395    { &search272_0.value, &search272_1.value },
   21396    NULL,
   21397 };
   21398 
   21399 #include "compiler/nir/nir_search_helpers.h"
   21400 static const nir_search_variable replace272_0 = {
   21401    { nir_search_value_variable, 0 },
   21402    0, /* c */
   21403    false,
   21404    nir_type_invalid,
   21405    NULL,
   21406 };
   21407 
   21408 #include "compiler/nir/nir_search_helpers.h"
   21409 static const nir_search_variable replace272_1_0 = {
   21410    { nir_search_value_variable, 0 },
   21411    1, /* a */
   21412    false,
   21413    nir_type_invalid,
   21414    NULL,
   21415 };
   21416 
   21417 #include "compiler/nir/nir_search_helpers.h"
   21418 static const nir_search_variable replace272_1_1 = {
   21419    { nir_search_value_variable, 0 },
   21420    2, /* b */
   21421    false,
   21422    nir_type_invalid,
   21423    NULL,
   21424 };
   21425 #include "compiler/nir/nir_search_helpers.h"
   21426 static const nir_search_expression replace272_1 = {
   21427    { nir_search_value_expression, 0 },
   21428    false,
   21429    nir_op_fmin,
   21430    { &replace272_1_0.value, &replace272_1_1.value },
   21431    NULL,
   21432 };
   21433 #include "compiler/nir/nir_search_helpers.h"
   21434 static const nir_search_expression replace272 = {
   21435    { nir_search_value_expression, 0 },
   21436    false,
   21437    nir_op_fadd,
   21438    { &replace272_0.value, &replace272_1.value },
   21439    NULL,
   21440 };
   21441 
   21442 static const struct transform nir_opt_algebraic_late_fmin_xforms[] = {
   21443    { &search272, &replace272.value, 0 },
   21444 };
   21445 
   21446 #include "compiler/nir/nir_search_helpers.h"
   21447 static const nir_search_variable search264_0_0 = {
   21448    { nir_search_value_variable, 0 },
   21449    0, /* a */
   21450    false,
   21451    nir_type_invalid,
   21452    NULL,
   21453 };
   21454 
   21455 #include "compiler/nir/nir_search_helpers.h"
   21456 static const nir_search_variable search264_0_1 = {
   21457    { nir_search_value_variable, 0 },
   21458    1, /* b */
   21459    false,
   21460    nir_type_invalid,
   21461    NULL,
   21462 };
   21463 #include "compiler/nir/nir_search_helpers.h"
   21464 static const nir_search_expression search264_0 = {
   21465    { nir_search_value_expression, 0 },
   21466    false,
   21467    nir_op_fadd,
   21468    { &search264_0_0.value, &search264_0_1.value },
   21469    NULL,
   21470 };
   21471 
   21472 #include "compiler/nir/nir_search_helpers.h"
   21473 static const nir_search_constant search264_1 = {
   21474    { nir_search_value_constant, 0 },
   21475    nir_type_float, { 0x0 /* 0.0 */ },
   21476 };
   21477 #include "compiler/nir/nir_search_helpers.h"
   21478 static const nir_search_expression search264 = {
   21479    { nir_search_value_expression, 0 },
   21480    true,
   21481    nir_op_feq,
   21482    { &search264_0.value, &search264_1.value },
   21483    NULL,
   21484 };
   21485 
   21486 #include "compiler/nir/nir_search_helpers.h"
   21487 static const nir_search_variable replace264_0 = {
   21488    { nir_search_value_variable, 0 },
   21489    0, /* a */
   21490    false,
   21491    nir_type_invalid,
   21492    NULL,
   21493 };
   21494 
   21495 #include "compiler/nir/nir_search_helpers.h"
   21496 static const nir_search_variable replace264_1_0 = {
   21497    { nir_search_value_variable, 0 },
   21498    1, /* b */
   21499    false,
   21500    nir_type_invalid,
   21501    NULL,
   21502 };
   21503 #include "compiler/nir/nir_search_helpers.h"
   21504 static const nir_search_expression replace264_1 = {
   21505    { nir_search_value_expression, 0 },
   21506    false,
   21507    nir_op_fneg,
   21508    { &replace264_1_0.value },
   21509    NULL,
   21510 };
   21511 #include "compiler/nir/nir_search_helpers.h"
   21512 static const nir_search_expression replace264 = {
   21513    { nir_search_value_expression, 0 },
   21514    false,
   21515    nir_op_feq,
   21516    { &replace264_0.value, &replace264_1.value },
   21517    NULL,
   21518 };
   21519 
   21520 static const struct transform nir_opt_algebraic_late_feq_xforms[] = {
   21521    { &search264, &replace264.value, 0 },
   21522 };
   21523 
   21524 #include "compiler/nir/nir_search_helpers.h"
   21525 static const nir_search_variable search263_0_0 = {
   21526    { nir_search_value_variable, 0 },
   21527    0, /* a */
   21528    false,
   21529    nir_type_invalid,
   21530    NULL,
   21531 };
   21532 
   21533 #include "compiler/nir/nir_search_helpers.h"
   21534 static const nir_search_variable search263_0_1 = {
   21535    { nir_search_value_variable, 0 },
   21536    1, /* b */
   21537    false,
   21538    nir_type_invalid,
   21539    NULL,
   21540 };
   21541 #include "compiler/nir/nir_search_helpers.h"
   21542 static const nir_search_expression search263_0 = {
   21543    { nir_search_value_expression, 0 },
   21544    false,
   21545    nir_op_fadd,
   21546    { &search263_0_0.value, &search263_0_1.value },
   21547    NULL,
   21548 };
   21549 
   21550 #include "compiler/nir/nir_search_helpers.h"
   21551 static const nir_search_constant search263_1 = {
   21552    { nir_search_value_constant, 0 },
   21553    nir_type_float, { 0x0 /* 0.0 */ },
   21554 };
   21555 #include "compiler/nir/nir_search_helpers.h"
   21556 static const nir_search_expression search263 = {
   21557    { nir_search_value_expression, 0 },
   21558    true,
   21559    nir_op_fge,
   21560    { &search263_0.value, &search263_1.value },
   21561    NULL,
   21562 };
   21563 
   21564 #include "compiler/nir/nir_search_helpers.h"
   21565 static const nir_search_variable replace263_0 = {
   21566    { nir_search_value_variable, 0 },
   21567    0, /* a */
   21568    false,
   21569    nir_type_invalid,
   21570    NULL,
   21571 };
   21572 
   21573 #include "compiler/nir/nir_search_helpers.h"
   21574 static const nir_search_variable replace263_1_0 = {
   21575    { nir_search_value_variable, 0 },
   21576    1, /* b */
   21577    false,
   21578    nir_type_invalid,
   21579    NULL,
   21580 };
   21581 #include "compiler/nir/nir_search_helpers.h"
   21582 static const nir_search_expression replace263_1 = {
   21583    { nir_search_value_expression, 0 },
   21584    false,
   21585    nir_op_fneg,
   21586    { &replace263_1_0.value },
   21587    NULL,
   21588 };
   21589 #include "compiler/nir/nir_search_helpers.h"
   21590 static const nir_search_expression replace263 = {
   21591    { nir_search_value_expression, 0 },
   21592    false,
   21593    nir_op_fge,
   21594    { &replace263_0.value, &replace263_1.value },
   21595    NULL,
   21596 };
   21597 
   21598 static const struct transform nir_opt_algebraic_late_fge_xforms[] = {
   21599    { &search263, &replace263.value, 0 },
   21600 };
   21601 
   21602 #include "compiler/nir/nir_search_helpers.h"
   21603 static const nir_search_variable search269_0 = {
   21604    { nir_search_value_variable, 0 },
   21605    0, /* a */
   21606    false,
   21607    nir_type_invalid,
   21608    NULL,
   21609 };
   21610 
   21611 #include "compiler/nir/nir_search_helpers.h"
   21612 static const nir_search_variable search269_1 = {
   21613    { nir_search_value_variable, 0 },
   21614    1, /* b */
   21615    false,
   21616    nir_type_invalid,
   21617    NULL,
   21618 };
   21619 #include "compiler/nir/nir_search_helpers.h"
   21620 static const nir_search_expression search269 = {
   21621    { nir_search_value_expression, 0 },
   21622    false,
   21623    nir_op_fdph,
   21624    { &search269_0.value, &search269_1.value },
   21625    NULL,
   21626 };
   21627 
   21628 #include "compiler/nir/nir_search_helpers.h"
   21629 static const nir_search_variable replace269_0 = {
   21630    { nir_search_value_variable, 0 },
   21631    0, /* a */
   21632    false,
   21633    nir_type_invalid,
   21634    NULL,
   21635 };
   21636 
   21637 #include "compiler/nir/nir_search_helpers.h"
   21638 static const nir_search_variable replace269_1 = {
   21639    { nir_search_value_variable, 0 },
   21640    1, /* b */
   21641    false,
   21642    nir_type_invalid,
   21643    NULL,
   21644 };
   21645 #include "compiler/nir/nir_search_helpers.h"
   21646 static const nir_search_expression replace269 = {
   21647    { nir_search_value_expression, 0 },
   21648    false,
   21649    nir_op_fdph_replicated,
   21650    { &replace269_0.value, &replace269_1.value },
   21651    NULL,
   21652 };
   21653 
   21654 static const struct transform nir_opt_algebraic_late_fdph_xforms[] = {
   21655    { &search269, &replace269.value, 37 },
   21656 };
   21657 
   21658 static bool
   21659 nir_opt_algebraic_late_block(nir_block *block, const bool *condition_flags,
   21660                    void *mem_ctx)
   21661 {
   21662    bool progress = false;
   21663 
   21664    nir_foreach_instr_reverse_safe(instr, block) {
   21665       if (instr->type != nir_instr_type_alu)
   21666          continue;
   21667 
   21668       nir_alu_instr *alu = nir_instr_as_alu(instr);
   21669       if (!alu->dest.dest.is_ssa)
   21670          continue;
   21671 
   21672       switch (alu->op) {
   21673       case nir_op_b2f:
   21674          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_b2f_xforms); i++) {
   21675             const struct transform *xform = &nir_opt_algebraic_late_b2f_xforms[i];
   21676             if (condition_flags[xform->condition_offset] &&
   21677                 nir_replace_instr(alu, xform->search, xform->replace,
   21678                                   mem_ctx)) {
   21679                progress = true;
   21680                break;
   21681             }
   21682          }
   21683          break;
   21684       case nir_op_fdot4:
   21685          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fdot4_xforms); i++) {
   21686             const struct transform *xform = &nir_opt_algebraic_late_fdot4_xforms[i];
   21687             if (condition_flags[xform->condition_offset] &&
   21688                 nir_replace_instr(alu, xform->search, xform->replace,
   21689                                   mem_ctx)) {
   21690                progress = true;
   21691                break;
   21692             }
   21693          }
   21694          break;
   21695       case nir_op_flt:
   21696          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_flt_xforms); i++) {
   21697             const struct transform *xform = &nir_opt_algebraic_late_flt_xforms[i];
   21698             if (condition_flags[xform->condition_offset] &&
   21699                 nir_replace_instr(alu, xform->search, xform->replace,
   21700                                   mem_ctx)) {
   21701                progress = true;
   21702                break;
   21703             }
   21704          }
   21705          break;
   21706       case nir_op_fdot2:
   21707          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fdot2_xforms); i++) {
   21708             const struct transform *xform = &nir_opt_algebraic_late_fdot2_xforms[i];
   21709             if (condition_flags[xform->condition_offset] &&
   21710                 nir_replace_instr(alu, xform->search, xform->replace,
   21711                                   mem_ctx)) {
   21712                progress = true;
   21713                break;
   21714             }
   21715          }
   21716          break;
   21717       case nir_op_fdot3:
   21718          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fdot3_xforms); i++) {
   21719             const struct transform *xform = &nir_opt_algebraic_late_fdot3_xforms[i];
   21720             if (condition_flags[xform->condition_offset] &&
   21721                 nir_replace_instr(alu, xform->search, xform->replace,
   21722                                   mem_ctx)) {
   21723                progress = true;
   21724                break;
   21725             }
   21726          }
   21727          break;
   21728       case nir_op_fneg:
   21729          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fneg_xforms); i++) {
   21730             const struct transform *xform = &nir_opt_algebraic_late_fneg_xforms[i];
   21731             if (condition_flags[xform->condition_offset] &&
   21732                 nir_replace_instr(alu, xform->search, xform->replace,
   21733                                   mem_ctx)) {
   21734                progress = true;
   21735                break;
   21736             }
   21737          }
   21738          break;
   21739       case nir_op_fmax:
   21740          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fmax_xforms); i++) {
   21741             const struct transform *xform = &nir_opt_algebraic_late_fmax_xforms[i];
   21742             if (condition_flags[xform->condition_offset] &&
   21743                 nir_replace_instr(alu, xform->search, xform->replace,
   21744                                   mem_ctx)) {
   21745                progress = true;
   21746                break;
   21747             }
   21748          }
   21749          break;
   21750       case nir_op_fne:
   21751          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fne_xforms); i++) {
   21752             const struct transform *xform = &nir_opt_algebraic_late_fne_xforms[i];
   21753             if (condition_flags[xform->condition_offset] &&
   21754                 nir_replace_instr(alu, xform->search, xform->replace,
   21755                                   mem_ctx)) {
   21756                progress = true;
   21757                break;
   21758             }
   21759          }
   21760          break;
   21761       case nir_op_fmin:
   21762          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fmin_xforms); i++) {
   21763             const struct transform *xform = &nir_opt_algebraic_late_fmin_xforms[i];
   21764             if (condition_flags[xform->condition_offset] &&
   21765                 nir_replace_instr(alu, xform->search, xform->replace,
   21766                                   mem_ctx)) {
   21767                progress = true;
   21768                break;
   21769             }
   21770          }
   21771          break;
   21772       case nir_op_feq:
   21773          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_feq_xforms); i++) {
   21774             const struct transform *xform = &nir_opt_algebraic_late_feq_xforms[i];
   21775             if (condition_flags[xform->condition_offset] &&
   21776                 nir_replace_instr(alu, xform->search, xform->replace,
   21777                                   mem_ctx)) {
   21778                progress = true;
   21779                break;
   21780             }
   21781          }
   21782          break;
   21783       case nir_op_fge:
   21784          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fge_xforms); i++) {
   21785             const struct transform *xform = &nir_opt_algebraic_late_fge_xforms[i];
   21786             if (condition_flags[xform->condition_offset] &&
   21787                 nir_replace_instr(alu, xform->search, xform->replace,
   21788                                   mem_ctx)) {
   21789                progress = true;
   21790                break;
   21791             }
   21792          }
   21793          break;
   21794       case nir_op_fdph:
   21795          for (unsigned i = 0; i < ARRAY_SIZE(nir_opt_algebraic_late_fdph_xforms); i++) {
   21796             const struct transform *xform = &nir_opt_algebraic_late_fdph_xforms[i];
   21797             if (condition_flags[xform->condition_offset] &&
   21798                 nir_replace_instr(alu, xform->search, xform->replace,
   21799                                   mem_ctx)) {
   21800                progress = true;
   21801                break;
   21802             }
   21803          }
   21804          break;
   21805       default:
   21806          break;
   21807       }
   21808    }
   21809 
   21810    return progress;
   21811 }
   21812 
   21813 static bool
   21814 nir_opt_algebraic_late_impl(nir_function_impl *impl, const bool *condition_flags)
   21815 {
   21816    void *mem_ctx = ralloc_parent(impl);
   21817    bool progress = false;
   21818 
   21819    nir_foreach_block_reverse(block, impl) {
   21820       progress |= nir_opt_algebraic_late_block(block, condition_flags, mem_ctx);
   21821    }
   21822 
   21823    if (progress)
   21824       nir_metadata_preserve(impl, nir_metadata_block_index |
   21825                                   nir_metadata_dominance);
   21826 
   21827    return progress;
   21828 }
   21829 
   21830 
   21831 bool
   21832 nir_opt_algebraic_late(nir_shader *shader)
   21833 {
   21834    bool progress = false;
   21835    bool condition_flags[38];
   21836    const nir_shader_compiler_options *options = shader->options;
   21837    (void) options;
   21838 
   21839    condition_flags[0] = true;
   21840    condition_flags[1] = options->lower_idiv;
   21841    condition_flags[2] = options->lower_flrp32;
   21842    condition_flags[3] = options->lower_flrp64;
   21843    condition_flags[4] = options->lower_ffract;
   21844    condition_flags[5] = !options->lower_flrp32;
   21845    condition_flags[6] = !options->lower_flrp64;
   21846    condition_flags[7] = options->lower_ffma;
   21847    condition_flags[8] = options->fuse_ffma;
   21848    condition_flags[9] = !options->lower_fsat;
   21849    condition_flags[10] = options->lower_fsat;
   21850    condition_flags[11] = options->lower_scmp;
   21851    condition_flags[12] = options->lower_fpow;
   21852    condition_flags[13] = !options->lower_fpow;
   21853    condition_flags[14] = options->lower_fdiv;
   21854    condition_flags[15] = options->lower_fsqrt;
   21855    condition_flags[16] = !options->lower_fsqrt;
   21856    condition_flags[17] = !options->lower_extract_byte;
   21857    condition_flags[18] = !options->lower_extract_word;
   21858    condition_flags[19] = options->lower_sub;
   21859    condition_flags[20] = options->lower_negate;
   21860    condition_flags[21] = options->lower_fmod32;
   21861    condition_flags[22] = options->lower_fmod64;
   21862    condition_flags[23] = options->lower_uadd_carry;
   21863    condition_flags[24] = options->lower_usub_borrow;
   21864    condition_flags[25] = options->lower_bitfield_insert;
   21865    condition_flags[26] = options->lower_bitfield_extract;
   21866    condition_flags[27] = options->lower_extract_byte;
   21867    condition_flags[28] = options->lower_extract_word;
   21868    condition_flags[29] = options->lower_pack_unorm_2x16;
   21869    condition_flags[30] = options->lower_pack_unorm_4x8;
   21870    condition_flags[31] = options->lower_pack_snorm_2x16;
   21871    condition_flags[32] = options->lower_pack_snorm_4x8;
   21872    condition_flags[33] = options->lower_unpack_unorm_2x16;
   21873    condition_flags[34] = options->lower_unpack_unorm_4x8;
   21874    condition_flags[35] = options->lower_unpack_snorm_2x16;
   21875    condition_flags[36] = options->lower_unpack_snorm_4x8;
   21876    condition_flags[37] = options->fdot_replicates;
   21877 
   21878    nir_foreach_function(function, shader) {
   21879       if (function->impl)
   21880          progress |= nir_opt_algebraic_late_impl(function->impl, condition_flags);
   21881    }
   21882 
   21883    return progress;
   21884 }
   21885 
   21886