SKIP: FAILED

../../src/tint/lang/msl/writer/printer/printer.cc:500 internal compiler error: buf0 = struct @align(8) {
  injectionSwitch:vec2<f32> @offset(0)
}

main_out = struct @align(16) {
  x_GLF_color_1:vec4<f32> @offset(0), @location(0)
}

$B1: {  # root
  %x_8:ptr<uniform, buf0, read> = var @binding_point(0, 0)
  %gl_FragCoord:ptr<private, vec4<f32>, read_write> = var
  %x_GLF_color:ptr<private, vec4<f32>, read_write> = var
  %continue_execution:ptr<private, bool, read_write> = var, true
}

%main_1 = func():void {
  $B2: {
    %temp:ptr<function, array<i32, 10>, read_write> = var
    %data:ptr<function, array<i32, 10>, read_write> = var
    %x_180:ptr<function, f32, read_write> = var
    %x_279:ptr<function, f32, read_write> = var
    %x_65_phi:ptr<function, i32, read_write> = var
    %x_93_phi:ptr<function, i32, read_write> = var
    %x_102_phi:ptr<function, i32, read_write> = var
    %x_280_phi:ptr<function, f32, read_write> = var
    %14:ptr<uniform, vec2<f32>, read> = access %x_8, 0u
    %15:f32 = load_vector_element %14, 0u
    %x_62:f32 = let %15
    %17:i32 = call %tint_f32_to_i32, %x_62
    %x_63:i32 = let %17
    store %x_65_phi, %x_63
    loop [b: $B3, c: $B4] {  # loop_1
      $B3: {  # body
        %20:i32 = load %x_65_phi
        %x_65:i32 = let %20
        switch %x_65 [c: (9i, $B5), c: (8i, $B6), c: (7i, $B7), c: (6i, $B8), c: (5i, $B9), c: (4i, $B10), c: (3i, $B11), c: (2i, $B12), c: (1i, $B13), c: (0i, $B14), c: (default, $B15)] {  # switch_1
          $B5: {  # case
            %22:ptr<function, i32, read_write> = access %data, %x_65
            store %22, -5i
            exit_switch  # switch_1
          }
          $B6: {  # case
            %23:ptr<function, i32, read_write> = access %data, %x_65
            store %23, -4i
            exit_switch  # switch_1
          }
          $B7: {  # case
            %24:ptr<function, i32, read_write> = access %data, %x_65
            store %24, -3i
            exit_switch  # switch_1
          }
          $B8: {  # case
            %25:ptr<function, i32, read_write> = access %data, %x_65
            store %25, -2i
            exit_switch  # switch_1
          }
          $B9: {  # case
            %26:ptr<function, i32, read_write> = access %data, %x_65
            store %26, -1i
            exit_switch  # switch_1
          }
          $B10: {  # case
            %27:ptr<function, i32, read_write> = access %data, %x_65
            store %27, 0i
            exit_switch  # switch_1
          }
          $B11: {  # case
            %28:ptr<function, i32, read_write> = access %data, %x_65
            store %28, 1i
            exit_switch  # switch_1
          }
          $B12: {  # case
            %29:ptr<function, i32, read_write> = access %data, %x_65
            store %29, 2i
            exit_switch  # switch_1
          }
          $B13: {  # case
            %30:ptr<function, i32, read_write> = access %data, %x_65
            store %30, 3i
            exit_switch  # switch_1
          }
          $B14: {  # case
            %31:ptr<function, i32, read_write> = access %data, %x_65
            store %31, 4i
            exit_switch  # switch_1
          }
          $B15: {  # case
            exit_switch  # switch_1
          }
        }
        %32:i32 = add %x_65, 1i
        %x_66:i32 = let %32
        continue  # -> $B4
      }
      $B4: {  # continuing
        store %x_65_phi, %x_66
        %34:bool = lt %x_66, 10i
        %35:bool = eq %34, false
        break_if %35  # -> [t: exit_loop loop_1, f: $B3]
      }
    }
    store %x_93_phi, 0i
    loop [b: $B16, c: $B17] {  # loop_2
      $B16: {  # body
        %x_94:ptr<function, i32, read_write> = var
        %37:i32 = load %x_93_phi
        %x_93:i32 = let %37
        %39:bool = lt %x_93, 10i
        if %39 [t: $B18, f: $B19] {  # if_1
          $B18: {  # true
            exit_if  # if_1
          }
          $B19: {  # false
            exit_loop  # loop_2
          }
        }
        continue  # -> $B17
      }
      $B17: {  # continuing
        %40:ptr<function, i32, read_write> = access %data, %x_93
        %41:i32 = load %40
        %x_99:i32 = let %41
        %43:ptr<function, i32, read_write> = access %temp, %x_93
        store %43, %x_99
        %44:i32 = add %x_93, 1i
        store %x_94, %44
        %45:i32 = load %x_94
        store %x_93_phi, %45
        next_iteration  # -> $B16
      }
    }
    store %x_102_phi, 1i
    loop [b: $B20, c: $B21] {  # loop_3
      $B20: {  # body
        %x_103:ptr<function, i32, read_write> = var
        %x_109_phi:ptr<function, i32, read_write> = var
        %48:i32 = load %x_102_phi
        %x_102:i32 = let %48
        %50:bool = lte %x_102, 9i
        if %50 [t: $B22, f: $B23] {  # if_2
          $B22: {  # true
            exit_if  # if_2
          }
          $B23: {  # false
            exit_loop  # loop_3
          }
        }
        store %x_109_phi, 0i
        loop [b: $B24, c: $B25] {  # loop_4
          $B24: {  # body
            %x_121:ptr<function, i32, read_write> = var
            %x_126:ptr<function, i32, read_write> = var
            %x_121_phi:ptr<function, i32, read_write> = var
            %x_124_phi:ptr<function, i32, read_write> = var
            %x_126_phi:ptr<function, i32, read_write> = var
            %x_148_phi:ptr<function, i32, read_write> = var
            %x_151_phi:ptr<function, i32, read_write> = var
            %x_161_phi:ptr<function, i32, read_write> = var
            %59:i32 = load %x_109_phi
            %x_109:i32 = let %59
            %61:bool = lt %x_109, 9i
            if %61 [t: $B26, f: $B27] {  # if_3
              $B26: {  # true
                exit_if  # if_3
              }
              $B27: {  # false
                exit_loop  # loop_4
              }
            }
            %62:i32 = add %x_109, %x_102
            %x_115:i32 = let %62
            %64:i32 = sub %x_115, 1i
            %x_116:i32 = let %64
            %66:i32 = mul 2i, %x_102
            %67:i32 = add %x_109, %66
            %x_110:i32 = let %67
            %69:i32 = sub %x_110, 1i
            %70:i32 = min %69, 9i
            %x_119:i32 = let %70
            store %x_121_phi, %x_109
            store %x_124_phi, %x_115
            store %x_126_phi, %x_109
            loop [b: $B28, c: $B29] {  # loop_5
              $B28: {  # body
                %x_141:ptr<function, i32, read_write> = var
                %x_144:ptr<function, i32, read_write> = var
                %x_125_phi:ptr<function, i32, read_write> = var
                %x_127_phi:ptr<function, i32, read_write> = var
                %76:i32 = load %x_121_phi
                store %x_121, %76
                %77:i32 = load %x_124_phi
                %x_124:i32 = let %77
                %79:i32 = load %x_126_phi
                store %x_126, %79
                %80:i32 = load %x_126
                %81:bool = lte %80, %x_116
                %82:bool = lte %x_124, %x_119
                %83:bool = and %81, %82
                if %83 [t: $B30, f: $B31] {  # if_4
                  $B30: {  # true
                    exit_if  # if_4
                  }
                  $B31: {  # false
                    exit_loop  # loop_5
                  }
                }
                %84:i32 = load %x_126
                %x_133_save:i32 = let %84
                %86:ptr<function, i32, read_write> = access %data, %x_133_save
                %87:i32 = load %86
                %x_134:i32 = let %87
                %x_135_save:i32 = let %x_124
                %90:ptr<function, i32, read_write> = access %data, %x_135_save
                %91:i32 = load %90
                %x_136:i32 = let %91
                %93:i32 = load %x_121
                %94:i32 = add %93, 1i
                %95:i32 = bitcast %94
                %x_122:i32 = let %95
                %97:bool = lt %x_134, %x_136
                if %97 [t: $B32, f: $B33] {  # if_5
                  $B32: {  # true
                    %98:i32 = load %x_126
                    %99:i32 = add %98, 1i
                    %100:i32 = bitcast %99
                    store %x_141, %100
                    %101:ptr<function, i32, read_write> = access %data, %x_133_save
                    %102:i32 = load %101
                    %x_142:i32 = let %102
                    %104:i32 = load %x_121
                    %105:ptr<function, i32, read_write> = access %temp, %104
                    store %105, %x_142
                    store %x_125_phi, %x_124
                    %106:i32 = load %x_141
                    store %x_127_phi, %106
                    exit_if  # if_5
                  }
                  $B33: {  # false
                    %107:i32 = add %x_124, 1i
                    store %x_144, %107
                    %108:ptr<function, i32, read_write> = access %data, %x_135_save
                    %109:i32 = load %108
                    %x_145:i32 = let %109
                    %111:i32 = load %x_121
                    %112:ptr<function, i32, read_write> = access %temp, %111
                    store %112, %x_145
                    %113:i32 = load %x_144
                    store %x_125_phi, %113
                    %114:i32 = load %x_126
                    store %x_127_phi, %114
                    exit_if  # if_5
                  }
                }
                %115:i32 = load %x_125_phi
                %x_125:i32 = let %115
                %117:i32 = load %x_127_phi
                %x_127:i32 = let %117
                continue  # -> $B29
              }
              $B29: {  # continuing
                store %x_121_phi, %x_122
                store %x_124_phi, %x_125
                store %x_126_phi, %x_127
                next_iteration  # -> $B28
              }
            }
            %119:i32 = load %x_121
            store %x_148_phi, %119
            %120:i32 = load %x_126
            store %x_151_phi, %120
            loop [b: $B34, c: $B35] {  # loop_6
              $B34: {  # body
                %x_149:ptr<function, i32, read_write> = var
                %x_152:ptr<function, i32, read_write> = var
                %123:i32 = load %x_148_phi
                %x_148:i32 = let %123
                %125:i32 = load %x_151_phi
                %x_151:i32 = let %125
                %127:bool = lt %x_151, 10i
                %128:bool = lte %x_151, %x_116
                %129:bool = and %127, %128
                if %129 [t: $B36, f: $B37] {  # if_6
                  $B36: {  # true
                    exit_if  # if_6
                  }
                  $B37: {  # false
                    exit_loop  # loop_6
                  }
                }
                continue  # -> $B35
              }
              $B35: {  # continuing
                %130:i32 = add %x_148, 1i
                store %x_149, %130
                %131:i32 = add %x_151, 1i
                store %x_152, %131
                %132:ptr<function, i32, read_write> = access %data, %x_151
                %133:i32 = load %132
                %x_158:i32 = let %133
                %135:ptr<function, i32, read_write> = access %temp, %x_148
                store %135, %x_158
                %136:i32 = load %x_149
                store %x_148_phi, %136
                %137:i32 = load %x_152
                store %x_151_phi, %137
                next_iteration  # -> $B34
              }
            }
            store %x_161_phi, %x_109
            loop [b: $B38, c: $B39] {  # loop_7
              $B38: {  # body
                %x_162:ptr<function, i32, read_write> = var
                %139:i32 = load %x_161_phi
                %x_161:i32 = let %139
                %141:bool = lte %x_161, %x_119
                if %141 [t: $B40, f: $B41] {  # if_7
                  $B40: {  # true
                    exit_if  # if_7
                  }
                  $B41: {  # false
                    exit_loop  # loop_7
                  }
                }
                continue  # -> $B39
              }
              $B39: {  # continuing
                %142:ptr<function, i32, read_write> = access %temp, %x_161
                %143:i32 = load %142
                %x_167:i32 = let %143
                %145:ptr<function, i32, read_write> = access %data, %x_161
                store %145, %x_167
                %146:i32 = add %x_161, 1i
                store %x_162, %146
                %147:i32 = load %x_162
                store %x_161_phi, %147
                next_iteration  # -> $B38
              }
            }
            continue  # -> $B25
          }
          $B25: {  # continuing
            store %x_109_phi, %x_110
            next_iteration  # -> $B24
          }
        }
        continue  # -> $B21
      }
      $B21: {  # continuing
        %148:i32 = mul 2i, %x_102
        store %x_103, %148
        %149:i32 = load %x_103
        store %x_102_phi, %149
        next_iteration  # -> $B20
      }
    }
    %x_171:ptr<function, i32, read_write> = var
    %x_189:ptr<function, f32, read_write> = var
    %x_278:ptr<function, f32, read_write> = var
    %x_279_phi:ptr<function, f32, read_write> = var
    %154:f32 = load_vector_element %gl_FragCoord, 1u
    %x_170:f32 = let %154
    %156:i32 = call %tint_f32_to_i32, %x_170
    store %x_171, %156
    %157:i32 = load %x_171
    %158:bool = lt %157, 30i
    if %158 [t: $B42, f: $B43] {  # if_8
      $B42: {  # true
        %159:ptr<function, i32, read_write> = access %data, 0i
        %160:i32 = load %159
        %x_177:i32 = let %160
        %162:f32 = convert %x_177
        %163:f32 = mul %162, 0.10000000149011611938f
        %164:f32 = add 0.5f, %163
        store %x_180, %164
        %165:f32 = load %x_180
        store %x_280_phi, %165
        exit_if  # if_8
      }
      $B43: {  # false
        %x_198:ptr<function, f32, read_write> = var
        %x_277:ptr<function, f32, read_write> = var
        %x_278_phi:ptr<function, f32, read_write> = var
        %169:i32 = load %x_171
        %170:bool = lt %169, 60i
        if %170 [t: $B44, f: $B45] {  # if_9
          $B44: {  # true
            %171:ptr<function, i32, read_write> = access %data, 1i
            %172:i32 = load %171
            %x_186:i32 = let %172
            %174:f32 = convert %x_186
            %175:f32 = mul %174, 0.10000000149011611938f
            %176:f32 = add 0.5f, %175
            store %x_189, %176
            %177:f32 = load %x_189
            store %x_279_phi, %177
            exit_if  # if_9
          }
          $B45: {  # false
            %x_207:ptr<function, f32, read_write> = var
            %x_249:ptr<function, f32, read_write> = var
            %x_277_phi:ptr<function, f32, read_write> = var
            %181:i32 = load %x_171
            %182:bool = lt %181, 90i
            if %182 [t: $B46, f: $B47] {  # if_10
              $B46: {  # true
                %183:ptr<function, i32, read_write> = access %data, 2i
                %184:i32 = load %183
                %x_195:i32 = let %184
                %186:f32 = convert %x_195
                %187:f32 = mul %186, 0.10000000149011611938f
                %188:f32 = add 0.5f, %187
                store %x_198, %188
                %189:f32 = load %x_198
                store %x_278_phi, %189
                exit_if  # if_10
              }
              $B47: {  # false
                %190:i32 = load %x_171
                %191:bool = lt %190, 120i
                if %191 [t: $B48, f: $B49] {  # if_11
                  $B48: {  # true
                    %192:ptr<function, i32, read_write> = access %data, 3i
                    %193:i32 = load %192
                    %x_204:i32 = let %193
                    %195:f32 = convert %x_204
                    %196:f32 = mul %195, 0.10000000149011611938f
                    %197:f32 = add 0.5f, %196
                    store %x_207, %197
                    %198:f32 = load %x_207
                    store %x_277_phi, %198
                    exit_if  # if_11
                  }
                  $B49: {  # false
                    %x_220:ptr<function, f32, read_write> = var
                    %x_248:ptr<function, f32, read_write> = var
                    %x_249_phi:ptr<function, f32, read_write> = var
                    %x_256_phi:ptr<function, vec2<f32>, read_write> = var
                    %x_259_phi:ptr<function, i32, read_write> = var
                    %204:i32 = load %x_171
                    %205:bool = lt %204, 150i
                    if %205 [t: $B50, f: $B51] {  # if_12
                      $B50: {  # true
                        store %continue_execution, false
                        exit_if  # if_12
                      }
                      $B51: {  # false
                        %x_229:ptr<function, f32, read_write> = var
                        %x_247:ptr<function, f32, read_write> = var
                        %x_248_phi:ptr<function, f32, read_write> = var
                        %209:i32 = load %x_171
                        %210:bool = lt %209, 180i
                        if %210 [t: $B52, f: $B53] {  # if_13
                          $B52: {  # true
                            %211:ptr<function, i32, read_write> = access %data, 5i
                            %212:i32 = load %211
                            %x_217:i32 = let %212
                            %214:f32 = convert %x_217
                            %215:f32 = mul %214, 0.10000000149011611938f
                            %216:f32 = add 0.5f, %215
                            store %x_220, %216
                            %217:f32 = load %x_220
                            store %x_249_phi, %217
                            exit_if  # if_13
                          }
                          $B53: {  # false
                            %x_238:ptr<function, f32, read_write> = var
                            %x_246:ptr<function, f32, read_write> = var
                            %x_247_phi:ptr<function, f32, read_write> = var
                            %221:i32 = load %x_171
                            %222:bool = lt %221, 210i
                            if %222 [t: $B54, f: $B55] {  # if_14
                              $B54: {  # true
                                %223:ptr<function, i32, read_write> = access %data, 6i
                                %224:i32 = load %223
                                %x_226:i32 = let %224
                                %226:f32 = convert %x_226
                                %227:f32 = mul %226, 0.10000000149011611938f
                                %228:f32 = add 0.5f, %227
                                store %x_229, %228
                                %229:f32 = load %x_229
                                store %x_248_phi, %229
                                exit_if  # if_14
                              }
                              $B55: {  # false
                                %230:i32 = load %x_171
                                %231:bool = lt %230, 240i
                                if %231 [t: $B56, f: $B57] {  # if_15
                                  $B56: {  # true
                                    %232:ptr<function, i32, read_write> = access %data, 7i
                                    %233:i32 = load %232
                                    %x_235:i32 = let %233
                                    %235:f32 = convert %x_235
                                    %236:f32 = mul %235, 0.10000000149011611938f
                                    %237:f32 = add 0.5f, %236
                                    store %x_238, %237
                                    %238:f32 = load %x_238
                                    store %x_247_phi, %238
                                    exit_if  # if_15
                                  }
                                  $B57: {  # false
                                    %239:i32 = load %x_171
                                    %240:bool = lt %239, 270i
                                    if %240 [t: $B58, f: $B59] {  # if_16
                                      $B58: {  # true
                                        exit_if  # if_16
                                      }
                                      $B59: {  # false
                                        store %continue_execution, false
                                        exit_if  # if_16
                                      }
                                    }
                                    %241:ptr<function, i32, read_write> = access %data, 8i
                                    %242:i32 = load %241
                                    %x_243:i32 = let %242
                                    %244:f32 = convert %x_243
                                    %245:f32 = mul %244, 0.10000000149011611938f
                                    %246:f32 = add 0.5f, %245
                                    store %x_246, %246
                                    %247:f32 = load %x_246
                                    store %x_247_phi, %247
                                    exit_if  # if_15
                                  }
                                }
                                %248:f32 = load %x_247_phi
                                store %x_247, %248
                                %249:f32 = load %x_247
                                store %x_248_phi, %249
                                exit_if  # if_14
                              }
                            }
                            %250:f32 = load %x_248_phi
                            store %x_248, %250
                            %251:f32 = load %x_248
                            store %x_249_phi, %251
                            exit_if  # if_13
                          }
                        }
                        %252:f32 = load %x_249_phi
                        store %x_249, %252
                        %253:ptr<uniform, vec2<f32>, read> = access %x_8, 0u
                        %254:f32 = load_vector_element %253, 1u
                        %x_251:f32 = let %254
                        %256:bool = gt %x_62, %x_251
                        %x_252:bool = let %256
                        if %x_252 [t: $B60] {  # if_17
                          $B60: {  # true
                            store %x_GLF_color, vec4<f32>(1.0f)
                            exit_if  # if_17
                          }
                        }
                        store %x_256_phi, vec2<f32>(1.0f)
                        store %x_259_phi, 0i
                        loop [b: $B61, c: $B62] {  # loop_8
                          $B61: {  # body
                            %x_272:ptr<function, vec2<f32>, read_write> = var
                            %x_260:ptr<function, i32, read_write> = var
                            %x_273_phi:ptr<function, vec2<f32>, read_write> = var
                            %261:vec2<f32> = load %x_256_phi
                            %x_256:vec2<f32> = let %261
                            %263:i32 = load %x_259_phi
                            %x_259:i32 = let %263
                            %265:bool = lte %x_259, 32i
                            if %265 [t: $B63, f: $B64] {  # if_18
                              $B63: {  # true
                                exit_if  # if_18
                              }
                              $B64: {  # false
                                exit_loop  # loop_8
                              }
                            }
                            store %x_273_phi, %x_256
                            %266:f32 = access %x_256, 0u
                            %267:bool = lt %266, 0.0f
                            if %267 [t: $B65] {  # if_19
                              $B65: {  # true
                                if %x_252 [t: $B66] {  # if_20
                                  $B66: {  # true
                                    store %continue_execution, false
                                    exit_if  # if_20
                                  }
                                }
                                store %x_272, %x_256
                                %268:f32 = access %x_256, 1u
                                %269:f32 = add %268, 1.0f
                                store_vector_element %x_272, 1u, %269
                                %270:vec2<f32> = load %x_272
                                store %x_273_phi, %270
                                exit_if  # if_19
                              }
                            }
                            %271:vec2<f32> = load %x_273_phi
                            %x_273:vec2<f32> = let %271
                            %x_257_1:ptr<function, vec2<f32>, read_write> = var, %x_273
                            %274:f32 = access %x_273, 0u
                            %275:f32 = access %x_273, 1u
                            %276:f32 = add %274, %275
                            store_vector_element %x_257_1, 0u, %276
                            %277:vec2<f32> = load %x_257_1
                            %x_257:vec2<f32> = let %277
                            continue  # -> $B62
                          }
                          $B62: {  # continuing
                            %279:i32 = add %x_259, 1i
                            store %x_260, %279
                            store %x_256_phi, %x_257
                            %280:i32 = load %x_260
                            store %x_259_phi, %280
                            next_iteration  # -> $B61
                          }
                        }
                        exit_if  # if_12
                      }
                    }
                    %281:f32 = load %x_249
                    store %x_277_phi, %281
                    exit_if  # if_11
                  }
                }
                %282:f32 = load %x_277_phi
                store %x_277, %282
                %283:f32 = load %x_277
                store %x_278_phi, %283
                exit_if  # if_10
              }
            }
            %284:f32 = load %x_278_phi
            store %x_278, %284
            %285:f32 = load %x_278
            store %x_279_phi, %285
            exit_if  # if_9
          }
        }
        %286:f32 = load %x_279_phi
        store %x_279, %286
        %287:f32 = load %x_279
        store %x_280_phi, %287
        exit_if  # if_8
      }
    }
    %288:f32 = load %x_280_phi
    %x_280:f32 = let %288
    %290:vec4<f32> = construct %x_280, %x_280, %x_280, 1.0f
    store %x_GLF_color, %290
    ret
  }
}
%tint_symbol = @fragment func(%gl_FragCoord_param:vec4<f32> [@position]):main_out {
  $B67: {
    store %gl_FragCoord, %gl_FragCoord_param
    %293:void = call %main_1
    %294:vec4<f32> = load %x_GLF_color
    %295:main_out = construct %294
    %296:bool = load %continue_execution
    %297:bool = eq %296, false
    if %297 [t: $B68] {  # if_21
      $B68: {  # true
        terminate_invocation
      }
    }
    ret %295
  }
}
%tint_f32_to_i32 = func(%value:f32):i32 {
  $B69: {
    %299:i32 = convert %value
    %300:bool = gte %value, -2147483648.0f
    %301:i32 = select -2147483648i, %299, %300
    %302:bool = lte %value, 2147483520.0f
    %303:i32 = select 2147483647i, %301, %302
    ret %303
  }
}

unhandled variable address space
********************************************************************
*  The tint shader compiler has encountered an unexpected error.   *
*                                                                  *
*  Please help us fix this issue by submitting a bug report at     *
*  crbug.com/tint with the source program that triggered the bug.  *
********************************************************************