SKIP: FAILED

../../src/tint/lang/msl/writer/printer/printer.cc:1257 internal compiler error: main_out = struct @align(16) {
  x_GLF_color_1:vec4<f32> @offset(0), @location(0)
}

$B1: {  # root
  %x_GLF_global_loop_count:ptr<private, i32, read_write> = var
  %x_GLF_color:ptr<private, vec4<f32>, read_write> = var
}

%main_1 = func():void {
  $B2: {
    %m23:ptr<function, mat2x3<f32>, read_write> = var
    %m24:ptr<function, mat2x4<f32>, read_write> = var
    %m32:ptr<function, mat3x2<f32>, read_write> = var
    %m33:ptr<function, mat3x3<f32>, read_write> = var
    %m34:ptr<function, mat3x4<f32>, read_write> = var
    %m42:ptr<function, mat4x2<f32>, read_write> = var
    %m43:ptr<function, mat4x3<f32>, read_write> = var
    %m44:ptr<function, mat4x4<f32>, read_write> = var
    %i:ptr<function, i32, read_write> = var
    %i_1:ptr<function, i32, read_write> = var
    %i_2:ptr<function, i32, read_write> = var
    %i_3:ptr<function, i32, read_write> = var
    %i_4:ptr<function, i32, read_write> = var
    %i_5:ptr<function, i32, read_write> = var
    %i_6:ptr<function, i32, read_write> = var
    %i_7:ptr<function, i32, read_write> = var
    %i_8:ptr<function, i32, read_write> = var
    %i_9:ptr<function, i32, read_write> = var
    %i_10:ptr<function, i32, read_write> = var
    %i_11:ptr<function, i32, read_write> = var
    %i_12:ptr<function, i32, read_write> = var
    %i_13:ptr<function, i32, read_write> = var
    %i_14:ptr<function, i32, read_write> = var
    %i_15:ptr<function, i32, read_write> = var
    %i_16:ptr<function, i32, read_write> = var
    %i_17:ptr<function, i32, read_write> = var
    %i_18:ptr<function, i32, read_write> = var
    %i_19:ptr<function, i32, read_write> = var
    %i_20:ptr<function, i32, read_write> = var
    %i_21:ptr<function, i32, read_write> = var
    %i_22:ptr<function, i32, read_write> = var
    %i_23:ptr<function, i32, read_write> = var
    %i_24:ptr<function, i32, read_write> = var
    %i_25:ptr<function, i32, read_write> = var
    %i_26:ptr<function, i32, read_write> = var
    %i_27:ptr<function, i32, read_write> = var
    %i_28:ptr<function, i32, read_write> = var
    %i_29:ptr<function, i32, read_write> = var
    %i_30:ptr<function, i32, read_write> = var
    %i_31:ptr<function, i32, read_write> = var
    %i_32:ptr<function, i32, read_write> = var
    %i_33:ptr<function, i32, read_write> = var
    %i_34:ptr<function, i32, read_write> = var
    %i_35:ptr<function, i32, read_write> = var
    %i_36:ptr<function, i32, read_write> = var
    %i_37:ptr<function, i32, read_write> = var
    %sum:ptr<function, f32, read_write> = var
    %r:ptr<function, i32, read_write> = var
    store %x_GLF_global_loop_count, 0i
    store %m23, mat2x3<f32>(vec3<f32>(0.0f))
    store %m24, mat2x4<f32>(vec4<f32>(0.0f))
    store %m32, mat3x2<f32>(vec2<f32>(0.0f))
    store %m33, mat3x3<f32>(vec3<f32>(0.0f))
    store %m34, mat3x4<f32>(vec4<f32>(0.0f))
    store %m42, mat4x2<f32>(vec2<f32>(0.0f))
    store %m43, mat4x3<f32>(vec3<f32>(0.0f))
    store %m44, mat4x4<f32>(vec4<f32>(0.0f))
    store %i, 0i
    loop [b: $B3, c: $B4] {  # loop_1
      $B3: {  # body
        %52:i32 = load %i
        %53:bool = lt %52, 1i
        if %53 [t: $B5, f: $B6] {  # if_1
          $B5: {  # true
            exit_if  # if_1
          }
          $B6: {  # false
            exit_loop  # loop_1
          }
        }
        store %i_1, 0i
        loop [b: $B7, c: $B8] {  # loop_2
          $B7: {  # body
            %54:i32 = load %i_1
            %55:bool = lt %54, 1i
            if %55 [t: $B9, f: $B10] {  # if_2
              $B9: {  # true
                exit_if  # if_2
              }
              $B10: {  # false
                exit_loop  # loop_2
              }
            }
            store %i_2, 0i
            loop [b: $B11, c: $B12] {  # loop_3
              $B11: {  # body
                %56:i32 = load %i_2
                %57:bool = lt %56, 1i
                if %57 [t: $B13, f: $B14] {  # if_3
                  $B13: {  # true
                    exit_if  # if_3
                  }
                  $B14: {  # false
                    exit_loop  # loop_3
                  }
                }
                store %i_3, 0i
                loop [b: $B15, c: $B16] {  # loop_4
                  $B15: {  # body
                    %58:i32 = load %i_3
                    %59:bool = lt %58, 1i
                    if %59 [t: $B17, f: $B18] {  # if_4
                      $B17: {  # true
                        exit_if  # if_4
                      }
                      $B18: {  # false
                        exit_loop  # loop_4
                      }
                    }
                    store %i_4, 0i
                    loop [b: $B19, c: $B20] {  # loop_5
                      $B19: {  # body
                        %60:i32 = load %i_4
                        %61:bool = lt %60, 1i
                        if %61 [t: $B21, f: $B22] {  # if_5
                          $B21: {  # true
                            exit_if  # if_5
                          }
                          $B22: {  # false
                            exit_loop  # loop_5
                          }
                        }
                        store %i_5, 0i
                        loop [b: $B23, c: $B24] {  # loop_6
                          $B23: {  # body
                            %62:i32 = load %i_5
                            %63:bool = lt %62, 1i
                            if %63 [t: $B25, f: $B26] {  # if_6
                              $B25: {  # true
                                exit_if  # if_6
                              }
                              $B26: {  # false
                                exit_loop  # loop_6
                              }
                            }
                            store %i_6, 0i
                            loop [b: $B27, c: $B28] {  # loop_7
                              $B27: {  # body
                                %64:i32 = load %i_6
                                %65:bool = lt %64, 1i
                                if %65 [t: $B29, f: $B30] {  # if_7
                                  $B29: {  # true
                                    exit_if  # if_7
                                  }
                                  $B30: {  # false
                                    exit_loop  # loop_7
                                  }
                                }
                                store %i_7, 0i
                                loop [b: $B31, c: $B32] {  # loop_8
                                  $B31: {  # body
                                    %66:i32 = load %i_7
                                    %67:bool = lt %66, 1i
                                    if %67 [t: $B33, f: $B34] {  # if_8
                                      $B33: {  # true
                                        exit_if  # if_8
                                      }
                                      $B34: {  # false
                                        exit_loop  # loop_8
                                      }
                                    }
                                    store %i_8, 0i
                                    loop [b: $B35, c: $B36] {  # loop_9
                                      $B35: {  # body
                                        %68:i32 = load %i_8
                                        %69:bool = lt %68, 1i
                                        if %69 [t: $B37, f: $B38] {  # if_9
                                          $B37: {  # true
                                            exit_if  # if_9
                                          }
                                          $B38: {  # false
                                            exit_loop  # loop_9
                                          }
                                        }
                                        store %i_9, 0i
                                        loop [b: $B39, c: $B40] {  # loop_10
                                          $B39: {  # body
                                            %70:i32 = load %i_9
                                            %71:bool = lt %70, 1i
                                            if %71 [t: $B41, f: $B42] {  # if_10
                                              $B41: {  # true
                                                exit_if  # if_10
                                              }
                                              $B42: {  # false
                                                exit_loop  # loop_10
                                              }
                                            }
                                            store %i_10, 0i
                                            loop [b: $B43, c: $B44] {  # loop_11
                                              $B43: {  # body
                                                %72:i32 = load %i_10
                                                %73:bool = lt %72, 1i
                                                if %73 [t: $B45, f: $B46] {  # if_11
                                                  $B45: {  # true
                                                    exit_if  # if_11
                                                  }
                                                  $B46: {  # false
                                                    exit_loop  # loop_11
                                                  }
                                                }
                                                store %i_11, 0i
                                                loop [b: $B47, c: $B48] {  # loop_12
                                                  $B47: {  # body
                                                    %74:i32 = load %i_11
                                                    %75:bool = lt %74, 1i
                                                    if %75 [t: $B49, f: $B50] {  # if_12
                                                      $B49: {  # true
                                                        exit_if  # if_12
                                                      }
                                                      $B50: {  # false
                                                        exit_loop  # loop_12
                                                      }
                                                    }
                                                    store %i_12, 0i
                                                    loop [b: $B51, c: $B52] {  # loop_13
                                                      $B51: {  # body
                                                        %76:i32 = load %i_12
                                                        %77:bool = lt %76, 1i
                                                        if %77 [t: $B53, f: $B54] {  # if_13
                                                          $B53: {  # true
                                                            exit_if  # if_13
                                                          }
                                                          $B54: {  # false
                                                            exit_loop  # loop_13
                                                          }
                                                        }
                                                        store %i_13, 0i
                                                        loop [b: $B55, c: $B56] {  # loop_14
                                                          $B55: {  # body
                                                            %78:i32 = load %i_13
                                                            %79:bool = lt %78, 1i
                                                            if %79 [t: $B57, f: $B58] {  # if_14
                                                              $B57: {  # true
                                                                exit_if  # if_14
                                                              }
                                                              $B58: {  # false
                                                                exit_loop  # loop_14
                                                              }
                                                            }
                                                            store %i_14, 0i
                                                            loop [b: $B59, c: $B60] {  # loop_15
                                                              $B59: {  # body
                                                                %80:i32 = load %i_14
                                                                %81:bool = lt %80, 1i
                                                                if %81 [t: $B61, f: $B62] {  # if_15
                                                                  $B61: {  # true
                                                                    exit_if  # if_15
                                                                  }
                                                                  $B62: {  # false
                                                                    exit_loop  # loop_15
                                                                  }
                                                                }
                                                                store %i_15, 0i
                                                                loop [b: $B63, c: $B64] {  # loop_16
                                                                  $B63: {  # body
                                                                    %82:i32 = load %i_15
                                                                    %83:bool = lt %82, 1i
                                                                    if %83 [t: $B65, f: $B66] {  # if_16
                                                                      $B65: {  # true
                                                                        exit_if  # if_16
                                                                      }
                                                                      $B66: {  # false
                                                                        exit_loop  # loop_16
                                                                      }
                                                                    }
                                                                    store %i_16, 0i
                                                                    loop [b: $B67, c: $B68] {  # loop_17
                                                                      $B67: {  # body
                                                                        %84:i32 = load %i_16
                                                                        %85:bool = lt %84, 1i
                                                                        if %85 [t: $B69, f: $B70] {  # if_17
                                                                          $B69: {  # true
                                                                            exit_if  # if_17
                                                                          }
                                                                          $B70: {  # false
                                                                            exit_loop  # loop_17
                                                                          }
                                                                        }
                                                                        store %i_17, 0i
                                                                        loop [b: $B71, c: $B72] {  # loop_18
                                                                          $B71: {  # body
                                                                            %86:i32 = load %i_17
                                                                            %87:bool = lt %86, 1i
                                                                            if %87 [t: $B73, f: $B74] {  # if_18
                                                                              $B73: {  # true
                                                                                exit_if  # if_18
                                                                              }
                                                                              $B74: {  # false
                                                                                exit_loop  # loop_18
                                                                              }
                                                                            }
                                                                            store %i_18, 0i
                                                                            loop [b: $B75, c: $B76] {  # loop_19
                                                                              $B75: {  # body
                                                                                %88:i32 = load %i_18
                                                                                %89:bool = lt %88, 1i
                                                                                if %89 [t: $B77, f: $B78] {  # if_19
                                                                                  $B77: {  # true
                                                                                    exit_if  # if_19
                                                                                  }
                                                                                  $B78: {  # false
                                                                                    exit_loop  # loop_19
                                                                                  }
                                                                                }
                                                                                store %i_19, 0i
                                                                                loop [b: $B79, c: $B80] {  # loop_20
                                                                                  $B79: {  # body
                                                                                    %90:i32 = load %i_19
                                                                                    %91:bool = lt %90, 1i
                                                                                    if %91 [t: $B81, f: $B82] {  # if_20
                                                                                      $B81: {  # true
                                                                                        exit_if  # if_20
                                                                                      }
                                                                                      $B82: {  # false
                                                                                        exit_loop  # loop_20
                                                                                      }
                                                                                    }
                                                                                    store %i_20, 0i
                                                                                    loop [b: $B83, c: $B84] {  # loop_21
                                                                                      $B83: {  # body
                                                                                        %92:i32 = load %i_20
                                                                                        %93:bool = lt %92, 1i
                                                                                        if %93 [t: $B85, f: $B86] {  # if_21
                                                                                          $B85: {  # true
                                                                                            exit_if  # if_21
                                                                                          }
                                                                                          $B86: {  # false
                                                                                            exit_loop  # loop_21
                                                                                          }
                                                                                        }
                                                                                        store %i_21, 0i
                                                                                        loop [b: $B87, c: $B88] {  # loop_22
                                                                                          $B87: {  # body
                                                                                            %94:i32 = load %i_21
                                                                                            %95:bool = lt %94, 1i
                                                                                            if %95 [t: $B89, f: $B90] {  # if_22
                                                                                              $B89: {  # true
                                                                                                exit_if  # if_22
                                                                                              }
                                                                                              $B90: {  # false
                                                                                                exit_loop  # loop_22
                                                                                              }
                                                                                            }
                                                                                            store %i_22, 0i
                                                                                            loop [b: $B91, c: $B92] {  # loop_23
                                                                                              $B91: {  # body
                                                                                                %96:i32 = load %i_22
                                                                                                %97:bool = lt %96, 1i
                                                                                                if %97 [t: $B93, f: $B94] {  # if_23
                                                                                                  $B93: {  # true
                                                                                                    exit_if  # if_23
                                                                                                  }
                                                                                                  $B94: {  # false
                                                                                                    exit_loop  # loop_23
                                                                                                  }
                                                                                                }
                                                                                                store %i_23, 0i
                                                                                                loop [b: $B95, c: $B96] {  # loop_24
                                                                                                  $B95: {  # body
                                                                                                    %98:i32 = load %i_23
                                                                                                    %99:bool = lt %98, 1i
                                                                                                    if %99 [t: $B97, f: $B98] {  # if_24
                                                                                                      $B97: {  # true
                                                                                                        exit_if  # if_24
                                                                                                      }
                                                                                                      $B98: {  # false
                                                                                                        exit_loop  # loop_24
                                                                                                      }
                                                                                                    }
                                                                                                    store %i_24, 0i
                                                                                                    loop [b: $B99, c: $B100] {  # loop_25
                                                                                                      $B99: {  # body
                                                                                                        %100:i32 = load %i_24
                                                                                                        %101:bool = lt %100, 1i
                                                                                                        if %101 [t: $B101, f: $B102] {  # if_25
                                                                                                          $B101: {  # true
                                                                                                            exit_if  # if_25
                                                                                                          }
                                                                                                          $B102: {  # false
                                                                                                            exit_loop  # loop_25
                                                                                                          }
                                                                                                        }
                                                                                                        store %i_25, 0i
                                                                                                        loop [b: $B103, c: $B104] {  # loop_26
                                                                                                          $B103: {  # body
                                                                                                            %102:i32 = load %i_25
                                                                                                            %103:bool = lt %102, 1i
                                                                                                            if %103 [t: $B105, f: $B106] {  # if_26
                                                                                                              $B105: {  # true
                                                                                                                exit_if  # if_26
                                                                                                              }
                                                                                                              $B106: {  # false
                                                                                                                exit_loop  # loop_26
                                                                                                              }
                                                                                                            }
                                                                                                            store %i_26, 0i
                                                                                                            loop [b: $B107, c: $B108] {  # loop_27
                                                                                                              $B107: {  # body
                                                                                                                %104:i32 = load %i_26
                                                                                                                %105:bool = lt %104, 1i
                                                                                                                if %105 [t: $B109, f: $B110] {  # if_27
                                                                                                                  $B109: {  # true
                                                                                                                    exit_if  # if_27
                                                                                                                  }
                                                                                                                  $B110: {  # false
                                                                                                                    exit_loop  # loop_27
                                                                                                                  }
                                                                                                                }
                                                                                                                store %i_27, 0i
                                                                                                                loop [b: $B111, c: $B112] {  # loop_28
                                                                                                                  $B111: {  # body
                                                                                                                    %106:i32 = load %i_27
                                                                                                                    %107:bool = lt %106, 1i
                                                                                                                    if %107 [t: $B113, f: $B114] {  # if_28
                                                                                                                      $B113: {  # true
                                                                                                                        exit_if  # if_28
                                                                                                                      }
                                                                                                                      $B114: {  # false
                                                                                                                        exit_loop  # loop_28
                                                                                                                      }
                                                                                                                    }
                                                                                                                    store %i_28, 0i
                                                                                                                    loop [b: $B115, c: $B116] {  # loop_29
                                                                                                                      $B115: {  # body
                                                                                                                        %108:i32 = load %i_28
                                                                                                                        %109:bool = lt %108, 1i
                                                                                                                        if %109 [t: $B117, f: $B118] {  # if_29
                                                                                                                          $B117: {  # true
                                                                                                                            exit_if  # if_29
                                                                                                                          }
                                                                                                                          $B118: {  # false
                                                                                                                            exit_loop  # loop_29
                                                                                                                          }
                                                                                                                        }
                                                                                                                        store %i_29, 0i
                                                                                                                        loop [b: $B119, c: $B120] {  # loop_30
                                                                                                                          $B119: {  # body
                                                                                                                            %110:i32 = load %i_29
                                                                                                                            %111:bool = lt %110, 1i
                                                                                                                            if %111 [t: $B121, f: $B122] {  # if_30
                                                                                                                              $B121: {  # true
                                                                                                                                exit_if  # if_30
                                                                                                                              }
                                                                                                                              $B122: {  # false
                                                                                                                                exit_loop  # loop_30
                                                                                                                              }
                                                                                                                            }
                                                                                                                            store %i_30, 0i
                                                                                                                            loop [b: $B123, c: $B124] {  # loop_31
                                                                                                                              $B123: {  # body
                                                                                                                                %112:i32 = load %i_30
                                                                                                                                %113:bool = lt %112, 1i
                                                                                                                                if %113 [t: $B125, f: $B126] {  # if_31
                                                                                                                                  $B125: {  # true
                                                                                                                                    exit_if  # if_31
                                                                                                                                  }
                                                                                                                                  $B126: {  # false
                                                                                                                                    exit_loop  # loop_31
                                                                                                                                  }
                                                                                                                                }
                                                                                                                                store %i_31, 0i
                                                                                                                                loop [b: $B127, c: $B128] {  # loop_32
                                                                                                                                  $B127: {  # body
                                                                                                                                    %114:i32 = load %i_31
                                                                                                                                    %115:bool = lt %114, 1i
                                                                                                                                    if %115 [t: $B129, f: $B130] {  # if_32
                                                                                                                                      $B129: {  # true
                                                                                                                                        exit_if  # if_32
                                                                                                                                      }
                                                                                                                                      $B130: {  # false
                                                                                                                                        exit_loop  # loop_32
                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                    store %i_32, 0i
                                                                                                                                    loop [b: $B131, c: $B132] {  # loop_33
                                                                                                                                      $B131: {  # body
                                                                                                                                        %116:i32 = load %i_32
                                                                                                                                        %117:bool = lt %116, 1i
                                                                                                                                        if %117 [t: $B133, f: $B134] {  # if_33
                                                                                                                                          $B133: {  # true
                                                                                                                                            exit_if  # if_33
                                                                                                                                          }
                                                                                                                                          $B134: {  # false
                                                                                                                                            exit_loop  # loop_33
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        store %i_33, 0i
                                                                                                                                        loop [b: $B135, c: $B136] {  # loop_34
                                                                                                                                          $B135: {  # body
                                                                                                                                            %118:i32 = load %i_33
                                                                                                                                            %119:bool = lt %118, 1i
                                                                                                                                            if %119 [t: $B137, f: $B138] {  # if_34
                                                                                                                                              $B137: {  # true
                                                                                                                                                exit_if  # if_34
                                                                                                                                              }
                                                                                                                                              $B138: {  # false
                                                                                                                                                exit_loop  # loop_34
                                                                                                                                              }
                                                                                                                                            }
                                                                                                                                            store %i_34, 0i
                                                                                                                                            loop [b: $B139, c: $B140] {  # loop_35
                                                                                                                                              $B139: {  # body
                                                                                                                                                %120:i32 = load %i_34
                                                                                                                                                %121:bool = lt %120, 1i
                                                                                                                                                if %121 [t: $B141, f: $B142] {  # if_35
                                                                                                                                                  $B141: {  # true
                                                                                                                                                    exit_if  # if_35
                                                                                                                                                  }
                                                                                                                                                  $B142: {  # false
                                                                                                                                                    exit_loop  # loop_35
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                                store %i_35, 0i
                                                                                                                                                loop [b: $B143, c: $B144] {  # loop_36
                                                                                                                                                  $B143: {  # body
                                                                                                                                                    %122:i32 = load %i_35
                                                                                                                                                    %123:bool = lt %122, 1i
                                                                                                                                                    if %123 [t: $B145, f: $B146] {  # if_36
                                                                                                                                                      $B145: {  # true
                                                                                                                                                        exit_if  # if_36
                                                                                                                                                      }
                                                                                                                                                      $B146: {  # false
                                                                                                                                                        exit_loop  # loop_36
                                                                                                                                                      }
                                                                                                                                                    }
                                                                                                                                                    store %i_36, 0i
                                                                                                                                                    loop [b: $B147, c: $B148] {  # loop_37
                                                                                                                                                      $B147: {  # body
                                                                                                                                                        %124:i32 = load %i_36
                                                                                                                                                        %125:bool = lt %124, 1i
                                                                                                                                                        if %125 [t: $B149, f: $B150] {  # if_37
                                                                                                                                                          $B149: {  # true
                                                                                                                                                            exit_if  # if_37
                                                                                                                                                          }
                                                                                                                                                          $B150: {  # false
                                                                                                                                                            exit_loop  # loop_37
                                                                                                                                                          }
                                                                                                                                                        }
                                                                                                                                                        store %i_37, 0i
                                                                                                                                                        loop [b: $B151, c: $B152] {  # loop_38
                                                                                                                                                          $B151: {  # body
                                                                                                                                                            %126:i32 = load %i_37
                                                                                                                                                            %127:bool = lt %126, 1i
                                                                                                                                                            if %127 [t: $B153, f: $B154] {  # if_38
                                                                                                                                                              $B153: {  # true
                                                                                                                                                                exit_if  # if_38
                                                                                                                                                              }
                                                                                                                                                              $B154: {  # false
                                                                                                                                                                exit_loop  # loop_38
                                                                                                                                                              }
                                                                                                                                                            }
                                                                                                                                                            loop [b: $B155, c: $B156] {  # loop_39
                                                                                                                                                              $B155: {  # body
                                                                                                                                                                %128:i32 = load %x_GLF_global_loop_count
                                                                                                                                                                %129:i32 = add %128, 1i
                                                                                                                                                                store %x_GLF_global_loop_count, %129
                                                                                                                                                                continue  # -> $B156
                                                                                                                                                              }
                                                                                                                                                              $B156: {  # continuing
                                                                                                                                                                %130:i32 = load %x_GLF_global_loop_count
                                                                                                                                                                %x_373:i32 = let %130
                                                                                                                                                                %132:bool = lt %x_373, 98i
                                                                                                                                                                %133:bool = eq %132, false
                                                                                                                                                                break_if %133  # -> [t: exit_loop loop_39, f: $B155]
                                                                                                                                                              }
                                                                                                                                                            }
                                                                                                                                                            %134:i32 = load %i_37
                                                                                                                                                            %x_375:i32 = let %134
                                                                                                                                                            %136:i32 = load %i_37
                                                                                                                                                            %x_376:i32 = let %136
                                                                                                                                                            %138:ptr<function, vec3<f32>, read_write> = access %m23, %x_375
                                                                                                                                                            store_vector_element %138, %x_376, 1.0f
                                                                                                                                                            %139:i32 = load %i_37
                                                                                                                                                            %x_378:i32 = let %139
                                                                                                                                                            %141:i32 = load %i_37
                                                                                                                                                            %x_379:i32 = let %141
                                                                                                                                                            %143:ptr<function, vec4<f32>, read_write> = access %m24, %x_378
                                                                                                                                                            store_vector_element %143, %x_379, 1.0f
                                                                                                                                                            %144:i32 = load %i_37
                                                                                                                                                            %x_381:i32 = let %144
                                                                                                                                                            %146:i32 = load %i_37
                                                                                                                                                            %x_382:i32 = let %146
                                                                                                                                                            %148:ptr<function, vec2<f32>, read_write> = access %m32, %x_381
                                                                                                                                                            store_vector_element %148, %x_382, 1.0f
                                                                                                                                                            %149:i32 = load %i_37
                                                                                                                                                            %x_384:i32 = let %149
                                                                                                                                                            %151:i32 = load %i_37
                                                                                                                                                            %x_385:i32 = let %151
                                                                                                                                                            %153:ptr<function, vec3<f32>, read_write> = access %m33, %x_384
                                                                                                                                                            store_vector_element %153, %x_385, 1.0f
                                                                                                                                                            %154:i32 = load %i_37
                                                                                                                                                            %x_387:i32 = let %154
                                                                                                                                                            %156:i32 = load %i_37
                                                                                                                                                            %x_388:i32 = let %156
                                                                                                                                                            %158:ptr<function, vec4<f32>, read_write> = access %m34, %x_387
                                                                                                                                                            store_vector_element %158, %x_388, 1.0f
                                                                                                                                                            %159:i32 = load %i_37
                                                                                                                                                            %x_390:i32 = let %159
                                                                                                                                                            %161:i32 = load %i_37
                                                                                                                                                            %x_391:i32 = let %161
                                                                                                                                                            %163:ptr<function, vec2<f32>, read_write> = access %m42, %x_390
                                                                                                                                                            store_vector_element %163, %x_391, 1.0f
                                                                                                                                                            %164:i32 = load %i_37
                                                                                                                                                            %x_393:i32 = let %164
                                                                                                                                                            %166:i32 = load %i_37
                                                                                                                                                            %x_394:i32 = let %166
                                                                                                                                                            %168:ptr<function, vec3<f32>, read_write> = access %m43, %x_393
                                                                                                                                                            store_vector_element %168, %x_394, 1.0f
                                                                                                                                                            %169:i32 = load %i_37
                                                                                                                                                            %x_396:i32 = let %169
                                                                                                                                                            %171:i32 = load %i_37
                                                                                                                                                            %x_397:i32 = let %171
                                                                                                                                                            %173:ptr<function, vec4<f32>, read_write> = access %m44, %x_396
                                                                                                                                                            store_vector_element %173, %x_397, 1.0f
                                                                                                                                                            continue  # -> $B152
                                                                                                                                                          }
                                                                                                                                                          $B152: {  # continuing
                                                                                                                                                            %174:i32 = load %i_37
                                                                                                                                                            %175:i32 = add %174, 1i
                                                                                                                                                            store %i_37, %175
                                                                                                                                                            next_iteration  # -> $B151
                                                                                                                                                          }
                                                                                                                                                        }
                                                                                                                                                        continue  # -> $B148
                                                                                                                                                      }
                                                                                                                                                      $B148: {  # continuing
                                                                                                                                                        %176:i32 = load %i_36
                                                                                                                                                        %177:i32 = add %176, 1i
                                                                                                                                                        store %i_36, %177
                                                                                                                                                        next_iteration  # -> $B147
                                                                                                                                                      }
                                                                                                                                                    }
                                                                                                                                                    continue  # -> $B144
                                                                                                                                                  }
                                                                                                                                                  $B144: {  # continuing
                                                                                                                                                    %178:i32 = load %i_35
                                                                                                                                                    %179:i32 = add %178, 1i
                                                                                                                                                    store %i_35, %179
                                                                                                                                                    next_iteration  # -> $B143
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                                continue  # -> $B140
                                                                                                                                              }
                                                                                                                                              $B140: {  # continuing
                                                                                                                                                %180:i32 = load %i_34
                                                                                                                                                %181:i32 = add %180, 1i
                                                                                                                                                store %i_34, %181
                                                                                                                                                next_iteration  # -> $B139
                                                                                                                                              }
                                                                                                                                            }
                                                                                                                                            continue  # -> $B136
                                                                                                                                          }
                                                                                                                                          $B136: {  # continuing
                                                                                                                                            %182:i32 = load %i_33
                                                                                                                                            %183:i32 = add %182, 1i
                                                                                                                                            store %i_33, %183
                                                                                                                                            next_iteration  # -> $B135
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        continue  # -> $B132
                                                                                                                                      }
                                                                                                                                      $B132: {  # continuing
                                                                                                                                        %184:i32 = load %i_32
                                                                                                                                        %185:i32 = add %184, 1i
                                                                                                                                        store %i_32, %185
                                                                                                                                        next_iteration  # -> $B131
                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                    continue  # -> $B128
                                                                                                                                  }
                                                                                                                                  $B128: {  # continuing
                                                                                                                                    %186:i32 = load %i_31
                                                                                                                                    %187:i32 = add %186, 1i
                                                                                                                                    store %i_31, %187
                                                                                                                                    next_iteration  # -> $B127
                                                                                                                                  }
                                                                                                                                }
                                                                                                                                continue  # -> $B124
                                                                                                                              }
                                                                                                                              $B124: {  # continuing
                                                                                                                                %188:i32 = load %i_30
                                                                                                                                %189:i32 = add %188, 1i
                                                                                                                                store %i_30, %189
                                                                                                                                next_iteration  # -> $B123
                                                                                                                              }
                                                                                                                            }
                                                                                                                            continue  # -> $B120
                                                                                                                          }
                                                                                                                          $B120: {  # continuing
                                                                                                                            %190:i32 = load %i_29
                                                                                                                            %191:i32 = add %190, 1i
                                                                                                                            store %i_29, %191
                                                                                                                            next_iteration  # -> $B119
                                                                                                                          }
                                                                                                                        }
                                                                                                                        continue  # -> $B116
                                                                                                                      }
                                                                                                                      $B116: {  # continuing
                                                                                                                        %192:i32 = load %i_28
                                                                                                                        %193:i32 = add %192, 1i
                                                                                                                        store %i_28, %193
                                                                                                                        next_iteration  # -> $B115
                                                                                                                      }
                                                                                                                    }
                                                                                                                    continue  # -> $B112
                                                                                                                  }
                                                                                                                  $B112: {  # continuing
                                                                                                                    %194:i32 = load %i_27
                                                                                                                    %195:i32 = add %194, 1i
                                                                                                                    store %i_27, %195
                                                                                                                    next_iteration  # -> $B111
                                                                                                                  }
                                                                                                                }
                                                                                                                continue  # -> $B108
                                                                                                              }
                                                                                                              $B108: {  # continuing
                                                                                                                %196:i32 = load %i_26
                                                                                                                %197:i32 = add %196, 1i
                                                                                                                store %i_26, %197
                                                                                                                next_iteration  # -> $B107
                                                                                                              }
                                                                                                            }
                                                                                                            continue  # -> $B104
                                                                                                          }
                                                                                                          $B104: {  # continuing
                                                                                                            %198:i32 = load %i_25
                                                                                                            %199:i32 = add %198, 1i
                                                                                                            store %i_25, %199
                                                                                                            next_iteration  # -> $B103
                                                                                                          }
                                                                                                        }
                                                                                                        continue  # -> $B100
                                                                                                      }
                                                                                                      $B100: {  # continuing
                                                                                                        %200:i32 = load %i_24
                                                                                                        %201:i32 = add %200, 1i
                                                                                                        store %i_24, %201
                                                                                                        next_iteration  # -> $B99
                                                                                                      }
                                                                                                    }
                                                                                                    continue  # -> $B96
                                                                                                  }
                                                                                                  $B96: {  # continuing
                                                                                                    %202:i32 = load %i_23
                                                                                                    %203:i32 = add %202, 1i
                                                                                                    store %i_23, %203
                                                                                                    next_iteration  # -> $B95
                                                                                                  }
                                                                                                }
                                                                                                continue  # -> $B92
                                                                                              }
                                                                                              $B92: {  # continuing
                                                                                                %204:i32 = load %i_22
                                                                                                %205:i32 = add %204, 1i
                                                                                                store %i_22, %205
                                                                                                next_iteration  # -> $B91
                                                                                              }
                                                                                            }
                                                                                            continue  # -> $B88
                                                                                          }
                                                                                          $B88: {  # continuing
                                                                                            %206:i32 = load %i_21
                                                                                            %207:i32 = add %206, 1i
                                                                                            store %i_21, %207
                                                                                            next_iteration  # -> $B87
                                                                                          }
                                                                                        }
                                                                                        continue  # -> $B84
                                                                                      }
                                                                                      $B84: {  # continuing
                                                                                        %208:i32 = load %i_20
                                                                                        %209:i32 = add %208, 1i
                                                                                        store %i_20, %209
                                                                                        next_iteration  # -> $B83
                                                                                      }
                                                                                    }
                                                                                    continue  # -> $B80
                                                                                  }
                                                                                  $B80: {  # continuing
                                                                                    %210:i32 = load %i_19
                                                                                    %211:i32 = add %210, 1i
                                                                                    store %i_19, %211
                                                                                    next_iteration  # -> $B79
                                                                                  }
                                                                                }
                                                                                continue  # -> $B76
                                                                              }
                                                                              $B76: {  # continuing
                                                                                %212:i32 = load %i_18
                                                                                %213:i32 = add %212, 1i
                                                                                store %i_18, %213
                                                                                next_iteration  # -> $B75
                                                                              }
                                                                            }
                                                                            continue  # -> $B72
                                                                          }
                                                                          $B72: {  # continuing
                                                                            %214:i32 = load %i_17
                                                                            %215:i32 = add %214, 1i
                                                                            store %i_17, %215
                                                                            next_iteration  # -> $B71
                                                                          }
                                                                        }
                                                                        continue  # -> $B68
                                                                      }
                                                                      $B68: {  # continuing
                                                                        %216:i32 = load %i_16
                                                                        %217:i32 = add %216, 1i
                                                                        store %i_16, %217
                                                                        next_iteration  # -> $B67
                                                                      }
                                                                    }
                                                                    continue  # -> $B64
                                                                  }
                                                                  $B64: {  # continuing
                                                                    %218:i32 = load %i_15
                                                                    %219:i32 = add %218, 1i
                                                                    store %i_15, %219
                                                                    next_iteration  # -> $B63
                                                                  }
                                                                }
                                                                continue  # -> $B60
                                                              }
                                                              $B60: {  # continuing
                                                                %220:i32 = load %i_14
                                                                %221:i32 = add %220, 1i
                                                                store %i_14, %221
                                                                next_iteration  # -> $B59
                                                              }
                                                            }
                                                            continue  # -> $B56
                                                          }
                                                          $B56: {  # continuing
                                                            %222:i32 = load %i_13
                                                            %223:i32 = add %222, 1i
                                                            store %i_13, %223
                                                            next_iteration  # -> $B55
                                                          }
                                                        }
                                                        continue  # -> $B52
                                                      }
                                                      $B52: {  # continuing
                                                        %224:i32 = load %i_12
                                                        %225:i32 = add %224, 1i
                                                        store %i_12, %225
                                                        next_iteration  # -> $B51
                                                      }
                                                    }
                                                    continue  # -> $B48
                                                  }
                                                  $B48: {  # continuing
                                                    %226:i32 = load %i_11
                                                    %227:i32 = add %226, 1i
                                                    store %i_11, %227
                                                    next_iteration  # -> $B47
                                                  }
                                                }
                                                continue  # -> $B44
                                              }
                                              $B44: {  # continuing
                                                %228:i32 = load %i_10
                                                %229:i32 = add %228, 1i
                                                store %i_10, %229
                                                next_iteration  # -> $B43
                                              }
                                            }
                                            continue  # -> $B40
                                          }
                                          $B40: {  # continuing
                                            %230:i32 = load %i_9
                                            %231:i32 = add %230, 1i
                                            store %i_9, %231
                                            next_iteration  # -> $B39
                                          }
                                        }
                                        continue  # -> $B36
                                      }
                                      $B36: {  # continuing
                                        %232:i32 = load %i_8
                                        %233:i32 = add %232, 1i
                                        store %i_8, %233
                                        next_iteration  # -> $B35
                                      }
                                    }
                                    continue  # -> $B32
                                  }
                                  $B32: {  # continuing
                                    %234:i32 = load %i_7
                                    %235:i32 = add %234, 1i
                                    store %i_7, %235
                                    next_iteration  # -> $B31
                                  }
                                }
                                continue  # -> $B28
                              }
                              $B28: {  # continuing
                                %236:i32 = load %i_6
                                %237:i32 = add %236, 1i
                                store %i_6, %237
                                next_iteration  # -> $B27
                              }
                            }
                            continue  # -> $B24
                          }
                          $B24: {  # continuing
                            %238:i32 = load %i_5
                            %239:i32 = add %238, 1i
                            store %i_5, %239
                            next_iteration  # -> $B23
                          }
                        }
                        continue  # -> $B20
                      }
                      $B20: {  # continuing
                        %240:i32 = load %i_4
                        %241:i32 = add %240, 1i
                        store %i_4, %241
                        next_iteration  # -> $B19
                      }
                    }
                    continue  # -> $B16
                  }
                  $B16: {  # continuing
                    %242:i32 = load %i_3
                    %243:i32 = add %242, 1i
                    store %i_3, %243
                    next_iteration  # -> $B15
                  }
                }
                continue  # -> $B12
              }
              $B12: {  # continuing
                %244:i32 = load %i_2
                %245:i32 = add %244, 1i
                store %i_2, %245
                next_iteration  # -> $B11
              }
            }
            continue  # -> $B8
          }
          $B8: {  # continuing
            %246:i32 = load %i_1
            %247:i32 = add %246, 1i
            store %i_1, %247
            next_iteration  # -> $B7
          }
        }
        continue  # -> $B4
      }
      $B4: {  # continuing
        %248:i32 = load %i
        %249:i32 = add %248, 1i
        store %i, %249
        next_iteration  # -> $B3
      }
    }
    store %sum, 0.0f
    store %r, 0i
    loop [b: $B157, c: $B158] {  # loop_40
      $B157: {  # body
        %250:i32 = load %x_GLF_global_loop_count
        %251:bool = lt %250, 100i
        if %251 [t: $B159, f: $B160] {  # if_39
          $B159: {  # true
            exit_if  # if_39
          }
          $B160: {  # false
            exit_loop  # loop_40
          }
        }
        %252:i32 = load %x_GLF_global_loop_count
        %253:i32 = add %252, 1i
        store %x_GLF_global_loop_count, %253
        %254:f32 = load %sum
        %255:ptr<function, vec3<f32>, read_write> = access %m23, 0i
        %256:i32 = load %r
        %257:f32 = load_vector_element %255, %256
        %258:f32 = add %254, %257
        store %sum, %258
        %259:f32 = load %sum
        %260:ptr<function, vec4<f32>, read_write> = access %m24, 0i
        %261:i32 = load %r
        %262:f32 = load_vector_element %260, %261
        %263:f32 = add %259, %262
        store %sum, %263
        %264:f32 = load %sum
        %265:ptr<function, vec2<f32>, read_write> = access %m32, 0i
        %266:i32 = load %r
        %267:f32 = load_vector_element %265, %266
        %268:f32 = add %264, %267
        store %sum, %268
        %269:f32 = load %sum
        %270:ptr<function, vec3<f32>, read_write> = access %m33, 0i
        %271:i32 = load %r
        %272:f32 = load_vector_element %270, %271
        %273:f32 = add %269, %272
        store %sum, %273
        %274:f32 = load %sum
        %275:ptr<function, vec4<f32>, read_write> = access %m34, 0i
        %276:i32 = load %r
        %277:f32 = load_vector_element %275, %276
        %278:f32 = add %274, %277
        store %sum, %278
        %279:f32 = load %sum
        %280:ptr<function, vec2<f32>, read_write> = access %m42, 0i
        %281:i32 = load %r
        %282:f32 = load_vector_element %280, %281
        %283:f32 = add %279, %282
        store %sum, %283
        %284:f32 = load %sum
        %285:ptr<function, vec3<f32>, read_write> = access %m43, 0i
        %286:i32 = load %r
        %287:f32 = load_vector_element %285, %286
        %288:f32 = add %284, %287
        store %sum, %288
        %289:f32 = load %sum
        %290:ptr<function, vec4<f32>, read_write> = access %m44, 0i
        %291:i32 = load %r
        %292:f32 = load_vector_element %290, %291
        %293:f32 = add %289, %292
        store %sum, %293
        continue  # -> $B158
      }
      $B158: {  # continuing
        %294:i32 = load %r
        %295:i32 = add %294, 1i
        store %r, %295
        next_iteration  # -> $B157
      }
    }
    %296:f32 = load %sum
    %297:bool = eq %296, 8.0f
    if %297 [t: $B161, f: $B162] {  # if_40
      $B161: {  # true
        store %x_GLF_color, vec4<f32>(1.0f, 0.0f, 0.0f, 1.0f)
        exit_if  # if_40
      }
      $B162: {  # false
        store %x_GLF_color, vec4<f32>(0.0f)
        exit_if  # if_40
      }
    }
    ret
  }
}
%tint_symbol = @fragment func():main_out {
  $B163: {
    %299:void = call %main_1
    %300:vec4<f32> = load %x_GLF_color
    %301:main_out = construct %300
    ret %301
  }
}

invalid entry point IO struct uses
********************************************************************
*  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.  *
********************************************************************