<style>
  :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; }
</style>
<script src="../../../resources/js-test-pre.js"></script>
<script id="shared">
const log = console.debug;

async function gc() {
  await 0;
  if (globalThis.GCController) {
    globalThis.GCController.collect();
  } else if (globalThis.$vm) {
    globalThis.$vm.gc();
  } else {
    log('no GC available');
  }
}

/**
 * @param {GPUDevice} device
 * @param {GPUComputePassEncoder} computePassEncoder
 */
function clearResourceUsages(device, computePassEncoder) {
  let code = `@compute @workgroup_size(1) fn c() {}`;
  let module = device.createShaderModule({code});
  computePassEncoder.setPipeline(device.createComputePipeline(
    {
      layout: 'auto',
      compute: {module},
    }));
  computePassEncoder.dispatchWorkgroups(1);
}

/**
 * @template {any} T
 * @param {GPUDevice} device
 * @param {string} label
 * @param {()=>T} payload
 * @returns {Promise<T>}
 */
async function validationWrapper(device, label, payload)  {
  device.pushErrorScope('internal');
  device.pushErrorScope('out-of-memory');
  device.pushErrorScope('validation');
  let result = payload();
  let validationError = await device.popErrorScope();
  let outOfMemoryError = await device.popErrorScope();
  let internalError = await device.popErrorScope();
  let error = validationError ?? outOfMemoryError ?? internalError;
  if (error) {
    log('*'.repeat(25));
    log(error[Symbol.toStringTag]);
    log(error.message);
    log(label);
    if (error.stack != `_`) {
      log(error.stack);
    }
    log(location);
    log('*'.repeat(25));
    throw error;
  }
  return result;
}

const videoUrls = [

];

/**
 * @param {number} index
 * @returns {Promise<HTMLVideoElement>}
 */
function videoWithData(index) {
  let video = document.createElement('video');
  video.src = videoUrls[index % videoUrls.length];
  return new Promise(resolve => {
    video.onloadeddata = () => {
      resolve(video);
    };
  });
}

/**
* @returns {Promise<string>}
*/
async function makeDataUrl(width, height, color0, color1) {
  let offscreenCanvas = new OffscreenCanvas(width, height);
  let ctx = offscreenCanvas.getContext('2d');
  let gradient = ctx.createLinearGradient(0, 0, width, height);
  gradient.addColorStop(0, color0);
  gradient.addColorStop(0.1, color1);
  gradient.addColorStop(0.3, color0);
  gradient.addColorStop(0.7, color1);
  gradient.addColorStop(0.9, color0);
  gradient.addColorStop(1, color1);
  ctx.fillStyle = gradient;
  ctx.fillRect(0, 0, width, height);
  let blob = await offscreenCanvas.convertToBlob();
  let fileReader = new FileReader();
  fileReader.readAsDataURL(blob);
  return new Promise(resolve => {
    fileReader.onload = () => {
      resolve(fileReader.result);
    };
  });
}

async function imageWithData(width, height, color0, color1) {
  let dataUrl = await makeDataUrl(width, height, color0, color1);
  let img = document.createElement('img');
  img.src = dataUrl;
  await img.decode();
  return img;
}

/**
 * @param {string} payload
 * @returns {string}
 */
function toBlobUrl(payload) {
  let blob = new Blob([payload], {type: 'text/javascript'});
  return URL.createObjectURL(blob);
}
</script>
<script>
globalThis.testRunner?.waitUntilDone();

async function window0() {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
    'float16-renderable',
    'core-features-and-limits',
    'timestamp-query',
  ],
});
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 82,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 436,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let commandEncoder0 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: [128, 128, 26],
  format: 'eac-rg11unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let commandEncoder1 = device0.createCommandEncoder();
let texture1 = device0.createTexture({
  size: {width: 80, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true, stencilReadOnly: true});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter0.label = '\u534b\u0936\u0f92\u{1f64a}\u{1ff53}\u0f10\u5950\u1a7a\u5af4\u8131';
} catch {}
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 82,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 436,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let textureView0 = texture0.createView({dimension: 'cube-array', arrayLayerCount: 6});
let texture2 = device0.createTexture({size: [40], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST});
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 82,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 436,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let buffer0 = device0.createBuffer({size: 36, usage: GPUBufferUsage.STORAGE});
let commandEncoder2 = device0.createCommandEncoder();
let textureView1 = texture1.createView({baseMipLevel: 0, mipLevelCount: 1});
let textureView2 = texture0.createView({dimension: 'cube', baseArrayLayer: 3});
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'smpte170m'} });
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 82,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 436,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout3, veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout1],
});
let sampler0 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 78.94, compare: 'equal'});
let pipelineLayout1 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0],
});
let commandEncoder3 = device0.createCommandEncoder();
let textureView3 = texture0.createView({dimension: 'cube-array', baseArrayLayer: 0, arrayLayerCount: 6});
let computePassEncoder0 = commandEncoder0.beginComputePass();
try {
device0.queue.submit([]);
} catch {}
await gc();
let commandEncoder4 = device0.createCommandEncoder({});
let texture3 = device0.createTexture({size: [160, 120, 36], format: 'rg32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
buffer0.unmap();
} catch {}
try {
commandEncoder2.insertDebugMarker('\ub42b');
} catch {}
let commandEncoder5 = device0.createCommandEncoder({});
let textureView4 = texture1.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 0});
try {
buffer0.unmap();
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]});
let commandEncoder6 = device0.createCommandEncoder();
let videoFrame1 = videoFrame0.clone();
let shaderModule0 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

enable f16;

/* used global variables: buffer10, buffer2, buffer3, et1, et3 */
@must_use 
fn fn1(a0: ptr<function, f16>) -> u32 {
  var out: u32;
  let ptr0: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer3[unconst_u32(119464450)][unconst_u32(888065090)][unconst_u32(63950127)][unconst_u32(64714670)];
  loop {
  let ptr1: ptr<storage, f16, read_write> = &(*&buffer3)[arrayLength(&(*&buffer3))][0][unconst_u32(1051389804)][unconst_u32(304548089)][0][unconst_u32(470937205)];
  _ = fn0();
  let ptr2: ptr<uniform, vec4f> = &(*&buffer10)[unconst_u32(3278408423)][0][unconst_u32(238194351)][0];
  break;
  _ = buffer10;
  _ = et3;
  _ = buffer3;
  _ = et1;
}
  {
  out = pack4xI8Clamp((*&buffer2)[unconst_u32(893946683)][0][7].location_7);
  _ = buffer2;
}
  let ptr3: ptr<storage, f16, read_write> = &buffer3[unconst_u32(336399353)][0][unconst_u32(1619556421)][unconst_u32(106159939)][unconst_u32(1001453521)][0];
  let ptr4: ptr<storage, f16, read_write> = &buffer3[unconst_u32(1955780111)][0][unconst_u32(53360426)][0][0][0];
  let ptr5: ptr<storage, array<f16, 1>, read_write> = &(*&buffer3)[unconst_u32(300307892)][unconst_u32(517182796)][60][unconst_u32(432327389)][0];
  return out;
  _ = buffer10;
  _ = et1;
  _ = et3;
  _ = buffer2;
  _ = buffer3;
}

@group(3) @binding(1) var tex3: texture_depth_2d;

fn unconst_f16(v: f16) -> f16 { return v; }

@group(3) @binding(37) var<storage, read_write> buffer8: array<array<array<f16, 61>, 1>>;

@group(0) @binding(0) var<storage, read_write> buffer1: array<array<array<array<array<f16, 1>, 1>, 20>, 8>>;

struct VertexInput3 {
  @location(8) location_8: vec4i,
}

@group(1) @binding(436) var et1: texture_external;

@group(0) @binding(1) var sam0: sampler_comparison;

struct T5 {
  f0: array<atomic<i32>>,
}

@group(3) @binding(144) var<uniform> buffer10: array<array<array<array<vec4f, 1>, 3>, 1>, 2>;

struct T1 {
  @align(4) f0: array<bool>,
}

struct VertexOutput0 {
  @location(8) location_8: vec4h,
  @builtin(position) position: vec4f,
  @location(6) @interpolate(perspective, centroid) location_6: vec2h,
  @location(13) location_13: vec2u,
}

fn unconst_i32(v: i32) -> i32 { return v; }

/* used global variables: et1, et3 */
@must_use 
fn fn0() -> vec4h {
  var out: vec4h;
  let vf0: vec4f = textureLoad(et1, vec2u(unconst_u32(1252920021), unconst_u32(926603625)));
  out = vec4h(f16(pack4xI8(vec4i(unconst_i32(237337379), unconst_i32(114259052), unconst_i32(84851739), unconst_i32(87157145)))));
  out = mix(vec3h(unconst_f16(-10284.5), unconst_f16(5430.4), unconst_f16(12655.5)), vec3h(unconst_f16(2252.0), unconst_f16(10686.8), unconst_f16(5261.4)), unconst_f16(3828.5)).grbb;
  let vf1: vec2u = textureDimensions(et1);
  var vf2: vec2h = inverseSqrt(mix(vec3h(unconst_f16(1658.2), unconst_f16(818.1), unconst_f16(22061.0)), vec3h(unconst_f16(1149.3), unconst_f16(7167.9), unconst_f16(1257.5)), unconst_f16(5524.9)).xy);
  vf2 *= out.br;
  out -= vec4h(vec4h(unconst_f16(9919.3), unconst_f16(4978.1), unconst_f16(26900.3), unconst_f16(10161.6)));
  var vf3: vec4u = (vec4u(unconst_u32(1333285427), unconst_u32(522708368), unconst_u32(576186117), unconst_u32(324585574)) / unconst_u32(169190413));
  let vf4: u32 = vf1[unconst_u32(529789045)];
  return out;
  _ = et3;
  _ = et1;
}

fn unconst_u32(v: u32) -> u32 { return v; }

var<workgroup> vw0: atomic<u32>;

struct VertexInput4 {
  @builtin(vertex_index) vertex_index: u32,
  @builtin(instance_index) instance_index: u32,
}

struct T4 {
  @align(64) f0: array<vec4i>,
}

/* used global variables: buffer3, buffer8, et1, et3 */
fn fn2(a0: ptr<uniform, vec4f>) -> vec2f {
  var out: vec2f;
  let ptr6: ptr<storage, f16, read_write> = &(*&buffer3)[arrayLength(&(*&buffer3))][unconst_u32(1604335472)][60][0][u32(buffer3[arrayLength(&buffer3)][0][unconst_u32(140933812)][unconst_u32(505657013)][0][0])][0];
  let ptr7: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer3[unconst_u32(39335350)][unconst_u32(384489539)][60][0];
  let ptr8: ptr<storage, array<f16, 1>, read_write> = &buffer3[arrayLength(&buffer3)][0][60][unconst_u32(632723924)][u32((*&buffer3)[arrayLength(&(*&buffer3))][0][unconst_u32(569326548)][0][0][0])];
  let ptr9: ptr<storage, f16, read_write> = &buffer3[arrayLength(&buffer3)][0][60][unconst_u32(160957773)][0][0];
  {
  out = vec2f(f32(buffer3[arrayLength(&buffer3)][unconst_u32(3639983204)][unconst_u32(622068659)][0][0][0]));
  _ = buffer3;
}
  var vf5 = fn0();
  while bool((*&buffer8)[arrayLength(&(*&buffer8))][0][60]) {
  if bool((*&buffer8)[arrayLength(&(*&buffer8)) - 1][0][60]) {
  var vf6 = fn0();
  var vf7 = fn0();
  break;
  _ = et1;
  _ = et3;
}
  _ = fn0();
  _ = et3;
  _ = et1;
  _ = buffer8;
}
  let vf8: vec4f = textureLoad(et1, vec2u(unconst_u32(769746358), unconst_u32(112936702)));
  let ptr10: ptr<storage, f16, read_write> = &buffer3[unconst_u32(26068463)][unconst_u32(13820355)][60][0][0][0];
  buffer3[unconst_u32(632572665)][unconst_u32(41983067)][60][u32((*&buffer8)[unconst_u32(4531791)][0][60])][unconst_u32(1076283985)][unconst_u32(185103923)] *= buffer3[unconst_u32(631262600)][unconst_u32(1151035096)][unconst_u32(1646346669)][0][0][unconst_u32(1096148788)];
  let ptr11: ptr<storage, f16, read_write> = &buffer3[unconst_u32(785250965)][unconst_u32(2359360469)][unconst_u32(110405579)][0][0][0];
  return out;
  _ = et3;
  _ = buffer8;
  _ = et1;
  _ = buffer3;
}

struct T0 {
  @size(122) f0: mat4x4h,
}

struct T3 {
  @size(256) f0: T0,
  @align(256) f1: array<atomic<u32>>,
}

struct ComputeInput0 {
  @builtin(global_invocation_id) global_invocation_id: vec3u,
  @builtin(num_workgroups) num_workgroups: vec3u,
}

@group(1) @binding(37) var<storage, read_write> buffer3: array<array<array<array<array<array<f16, 1>, 1>, 1>, 61>, 1>>;

struct T2 {
  @align(8) f0: array<array<atomic<i32>, 2>>,
}

struct ComputeInput1 {
  @builtin(local_invocation_index) local_invocation_index: u32,
}

@group(1) @binding(144) var<uniform> buffer5: array<array<array<vec4i, 2>, 1>, 3>;

@group(3) @binding(436) var et3: texture_external;

@group(2) @binding(70) var<uniform> buffer7: array<array<FragmentOutput0, 2>, 4>;

struct VertexInput0 {
  @location(10) location_10: vec2i,
  @location(2) location_2: vec2i,
  @location(1) location_1: vec2u,
  @location(5) location_5: vec2u,
  @location(15) location_15: vec4u,
}

fn unconst_f32(v: f32) -> f32 { return v; }

/* used global variables: et1, et3 */
@must_use 
fn fn3() -> array<f16, 3> {
  var out: array<f16, 3>;
  let vf9: vec2<bool> = (vec2f(unconst_f32(0.3393), unconst_f32(0.1327e19)) >= vec2f(unconst_f32(0.01464), unconst_f32(-0.1574)));
  var vf10: vec4f = refract(vec4f(unconst_f32(-0.05748e4), unconst_f32(0.07606), unconst_f32(0.1865), unconst_f32(0.07351e-26)), vec4f(unconst_f32(0.2648e-38), unconst_f32(0.3099), unconst_f32(-0.2170), unconst_f32(0.4079e27)), unconst_f32(0.1537));
  let ptr12: ptr<function, f16> = &out[unconst_u32(119128036)];
  for (var it0=vec3u((vec3h(unconst_f16(2230.0), unconst_f16(32010.9), unconst_f16(2229.0)) - vec3h(unconst_f16(15105.7), unconst_f16(5952.3), unconst_f16(23135.6))).gbb.brb)[1]; it0<(u32(out[unconst_u32(698647453)]) & 0xfff); it0++) {
  out[unconst_u32(509472933)] = out[2];
  loop {
  var vf11 = fn0();
  var vf12 = fn0();
  break;
  _ = et3;
  _ = et1;
}
  while (unconst_bool(true) && unconst_bool(false)) {
  out[unconst_u32(2193253248)] = out[2];
}
  out[unconst_u32(1530129019)] -= f16(unconst_f16(557.1));
  out[unconst_u32(765018132)] += out[2];
  return out;
  _ = et3;
  _ = et1;
}
  out[unconst_u32(48398625)] = vec2h(unpack2x16unorm(unconst_u32(541869473)))[1];
  vf10 -= smoothstep(vec4f(unconst_f32(0.2054), unconst_f32(0.02822e32), unconst_f32(0.4480), unconst_f32(0.1472)), vec4f(unconst_f32(0.00057e-16), unconst_f32(0.09849e-7), unconst_f32(0.02632e34), unconst_f32(0.3723)), vec4f(unconst_f32(0.02120e0), unconst_f32(0.05476), unconst_f32(0.02590), unconst_f32(0.05489)));
  let vf13: vec3h = (vec3h(unconst_f16(6220.1), unconst_f16(13680.8), unconst_f16(26959.5)) - vec3h(unconst_f16(-1572.3), unconst_f16(690.1), unconst_f16(-572.8)));
  vf10 = ldexp(vec3f(unconst_f32(0.1072e0), unconst_f32(0.03246), unconst_f32(0.1087e14)), vec3i(unconst_i32(149151983), unconst_i32(52515776), unconst_i32(95811775))).xyyz;
  switch u32(out[unconst_u32(585272556)]) { 
  case 219512878, default, 1991064499: {
  var vf14: vec3i = extractBits(vec3i(unconst_i32(342698361), unconst_i32(105998057), unconst_i32(600592228)), unconst_u32(689296850), unconst_u32(936776594));
  break;
}
  }
  return out;
  _ = et3;
  _ = et1;
}

fn unconst_bool(v: bool) -> bool { return v; }

alias vec3b = vec3<bool>;

struct VertexInput1 {
  @location(7) location_7: vec2h,
}

struct FragmentOutput0 {
  @location(7) @interpolate(flat, center) location_7: vec4i,
  @location(0) @interpolate(flat) location_0: vec4u,
}

struct VertexInput2 {
  @location(14) @interpolate(perspective, first) location_14: vec2f,
}

@group(0) @binding(70) var<uniform> buffer2: array<array<array<FragmentOutput0, 8>, 1>, 1>;

/* used global variables: buffer10, buffer5, et1, et3 */
@vertex
fn vertex0(a0: VertexInput0, @location(3) location_3: vec2f, @location(0) location_0: vec4h, @location(9) location_9: vec2i, @location(11) @interpolate(flat) location_11: i32, a5: VertexInput1, a6: VertexInput2, a7: VertexInput3, a8: VertexInput4, @location(6) location_6: vec4h, @location(4) @interpolate(linear) location_4: vec4f, @location(12) @interpolate(linear, center) location_12: f16) -> VertexOutput0 {
  var out: VertexOutput0;
  let ptr13: ptr<uniform, vec4f> = &(*&buffer10)[1][unconst_u32(498482232)][2][u32(buffer5[2][0][1].a)];
  var vf15 = fn3();
  _ = fn3();
  out.position = vec4f(f32(buffer5[unconst_u32(156242347)][0][1][unconst_u32(289236416)]));
  out.location_6 = a5.location_7;
  return out;
  _ = buffer5;
  _ = et1;
  _ = buffer10;
  _ = et3;
}

/* used global variables: buffer10, buffer2, buffer3, buffer7, buffer8, et1, et3, sam0, tex3 */
@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  let ptr14: ptr<storage, f16, read_write> = &buffer3[arrayLength(&buffer3)][0][unconst_u32(1413310118)][unconst_u32(1227431827)][unconst_u32(763026885)][unconst_u32(1232284644)];
  let ptr15: ptr<storage, array<f16, 1>, read_write> = &(*&buffer3)[unconst_u32(356147174)][0][unconst_u32(646835637)][0][0];
  out = buffer7[unconst_u32(544073354)][unconst_u32(554864958)];
  _ = fn3();
  let ptr16: ptr<uniform, vec4i> = &(*&buffer2)[unconst_u32(1039358412)][0][7].location_7;
  var vf16 = fn2(&buffer10[1][0][2][unconst_u32(1112488970)]);
  var vf17: vec4f = textureGatherCompare(tex3, sam0, vec2f(unconst_f32(0.1082), unconst_f32(0.3975e25)), unconst_f32(-0.1195e29));
  vf17 -= vec4f(f32((*&buffer3)[arrayLength(&(*&buffer3))][unconst_u32(1060895352)][60][0][0][unconst_u32(1480151287)]));
  return out;
  _ = buffer10;
  _ = buffer2;
  _ = buffer3;
  _ = sam0;
  _ = et3;
  _ = et1;
  _ = buffer7;
  _ = buffer8;
  _ = tex3;
}

/* used global variables: buffer1, buffer3, buffer8, et1, et3 */
@compute @workgroup_size(8, 1, 2)
fn compute0(a0: ComputeInput0, a1: ComputeInput1, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) {
  var vf18: u32 = atomicLoad(&vw0);
  var vf19 = fn3();
  buffer1[unconst_u32(413687389)][unconst_u32(571154783)][19][unconst_u32(82967563)][unconst_u32(554898092)] += buffer3[unconst_u32(123509912)][unconst_u32(503441112)][60][0][unconst_u32(128548198)][0];
  buffer8[unconst_u32(33851746)][0][unconst_u32(1179756172)] = f16(vf18);
  _ = fn0();
  let ptr17: ptr<storage, array<f16, 1>, read_write> = &(*&buffer3)[unconst_u32(235856461)][unconst_u32(1409783650)][unconst_u32(92803052)][unconst_u32(1120222987)][unconst_u32(1355127261)];
  _ = buffer1;
  _ = buffer3;
  _ = et3;
  _ = buffer8;
  _ = et1;
}`,
});
let buffer11 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder7 = device0.createCommandEncoder();
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(3).fill(37), /* required buffer size: 3 */
{offset: 3}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline0 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule0, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.BLUE}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 8,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm8x2', offset: 0, shaderLocation: 14},
          {format: 'sint8x2', offset: 0, shaderLocation: 2},
          {format: 'float16x4', offset: 0, shaderLocation: 12},
          {format: 'uint8x2', offset: 2, shaderLocation: 15},
          {format: 'sint8x4', offset: 0, shaderLocation: 11},
          {format: 'float32', offset: 0, shaderLocation: 4},
          {format: 'sint32x2', offset: 0, shaderLocation: 10},
          {format: 'sint32x2', offset: 0, shaderLocation: 8},
          {format: 'sint32x2', offset: 0, shaderLocation: 9},
          {format: 'unorm16x2', offset: 0, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 758, shaderLocation: 3},
          {format: 'uint32x4', offset: 96, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 436,
        attributes: [
          {format: 'unorm16x4', offset: 56, shaderLocation: 7},
          {format: 'uint8x4', offset: 80, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 48,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x4', offset: 4, shaderLocation: 0}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let commandEncoder8 = device0.createCommandEncoder({label: '\uc7ef\u0337'});
let texture4 = device0.createTexture({size: [20, 15, 82], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder1 = commandEncoder1.beginComputePass();
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], stencilReadOnly: true});
let buffer12 = device0.createBuffer({size: 106, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
try {
commandEncoder6.copyBufferToBuffer(buffer12, 40, buffer11, 4, 4);
} catch {}
try {
globalThis.someLabel = veryExplicitBindGroupLayout1.label;
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let texture5 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 1},
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView5 = texture3.createView({baseArrayLayer: 5, arrayLayerCount: 4});
let buffer13 = device0.createBuffer({size: 532, usage: GPUBufferUsage.INDIRECT});
let textureView6 = texture5.createView({aspect: 'all'});
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 51},
  aspect: 'all',
}, new Uint8Array(71).fill(56), /* required buffer size: 71 */
{offset: 71, rowsPerImage: 72}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture6 = device0.createTexture({
  size: [30, 30, 12],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let textureView7 = texture0.createView({dimension: '2d', baseArrayLayer: 10});
let computePassEncoder2 = commandEncoder9.beginComputePass();
try {
renderBundleEncoder1.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 0, new DataView(new Uint8Array(4878).map((_, i) => i).buffer), 1495, 4);
} catch {}
let commandEncoder10 = device0.createCommandEncoder({});
try {
renderBundleEncoder0.setVertexBuffer(2, undefined, 1_182_126_490, 31_480_441);
} catch {}
let buffer14 = device0.createBuffer({size: 56, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
try {
renderBundleEncoder0.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 0, new Float32Array(9569).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4026)), 4277, 0);
} catch {}
let imageData0 = new ImageData(24, 20);
let commandEncoder11 = device0.createCommandEncoder({});
try {
renderBundleEncoder1.setIndexBuffer(buffer12, 'uint16', 26, 18);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline0);
} catch {}
let commandEncoder12 = device0.createCommandEncoder({});
let canvas0 = document.createElement('canvas');
await gc();
try {
globalThis.someLabel = device0.label;
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 82,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 436,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let texture7 = device0.createTexture({
  label: '\u65f1\ucb8b\u0879\u08a7\u5557\u10bd',
  size: {width: 120, height: 120, depthOrArrayLayers: 49},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView8 = texture1.createView({mipLevelCount: 1});
let computePassEncoder3 = commandEncoder6.beginComputePass();
try {
renderBundleEncoder0.setIndexBuffer(buffer14, 'uint16', 26, 2);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture8 = device0.createTexture({
  size: [128],
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder4 = commandEncoder10.beginComputePass();
let buffer15 = device0.createBuffer({size: 135, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let computePassEncoder5 = commandEncoder4.beginComputePass();
try {
renderBundleEncoder1.setPipeline(pipeline0);
} catch {}
let buffer16 = device0.createBuffer({size: 44, usage: GPUBufferUsage.UNIFORM});
let commandEncoder13 = device0.createCommandEncoder({});
let computePassEncoder6 = commandEncoder12.beginComputePass();
document.body.append(canvas0);
let imageData1 = new ImageData(24, 112);
try {
  await shaderModule0.getCompilationInfo();
} catch {}
let textureView9 = texture3.createView({aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 16});
try {
renderBundleEncoder1.setIndexBuffer(buffer12, 'uint32', 28, 9);
} catch {}
let buffer17 = device0.createBuffer({size: 323, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder14 = device0.createCommandEncoder({});
try {
renderBundleEncoder0.setIndexBuffer(buffer14, 'uint32', 12, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 16, new Uint32Array(4369).map((_, i) => i * 8), 1383, 4);
} catch {}
try {
textureView8.label = '\u0b86\u{1fce9}\u{1f85e}';
} catch {}
let buffer18 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDIRECT});
let commandEncoder15 = device0.createCommandEncoder({label: '\u0a3c\ub342\u0dac\u7fb6\u651e\u{1fbbf}\uc5b5\u2110'});
try {
renderBundleEncoder0.setVertexBuffer(2, buffer17, 160, 8);
} catch {}
try {
commandEncoder15.clearBuffer(buffer15, 4, 0);
} catch {}
try {
commandEncoder15.insertDebugMarker('\u231f');
} catch {}
let gpuCanvasContext0 = canvas0.getContext('webgpu');
await gc();
try {
renderBundleEncoder1.setVertexBuffer(0, buffer17, 0, 41);
} catch {}
try {
commandEncoder14.copyBufferToBuffer(buffer17, 4, buffer15, 60, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture9 = device0.createTexture({
  size: [60, 60, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
device0.queue.writeBuffer(buffer15, 4, new Float32Array(16489).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.5740)), 1182, 12);
} catch {}
document.body.append(canvas0);
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

requires unrestricted_pointer_parameters;

struct T0 {
  @size(88) f0: vec2h,
}

@id(48437) override override4: bool;

@group(0) @binding(37) var<storage, read_write> buffer19: array<array<f16, 61>>;

struct FragmentOutput1 {
  @location(0) @interpolate(flat) location_0: vec4u,
  @builtin(sample_mask) sample_mask: u32,
}

var<workgroup> vw1: atomic<i32>;

/* used global variables: buffer20 */
fn fn0(a0: ptr<storage, array<f16, 61>, read_write>) {
  let ptr18: ptr<storage, array<f16, 1>, read> = &buffer20[unconst_u32(1265281659)][u32(buffer20[3][unconst_u32(1374367397)][0][unconst_u32(677042792)][0][unconst_u32(1445862285)])][0][unconst_u32(234428678)][unconst_u32(65224701)];
  (*a0)[unconst_u32(535563549)] -= (*&buffer20)[unconst_u32(698221477)][1][unconst_u32(1920311687)][u32(buffer20[3][1][0][0][0][0])][unconst_u32(269125335)][unconst_u32(1108829031)];
  let ptr19: ptr<storage, f16, read> = &(*&buffer20)[3][unconst_u32(394140240)][0][0][unconst_u32(9282960)][0];
  _ = buffer20;
}

fn unconst_f32(v: f32) -> f32 { return v; }

struct FragmentInput2 {
  @builtin(sample_mask) sample_mask: u32,
}

override override0: u32;

@group(1) @binding(1) var tex7: texture_depth_2d;

struct T1 {
  @size(32) f0: i32,
  @size(64) f1: atomic<i32>,
}

@group(0) @binding(144) var<uniform> buffer21: array<array<array<array<mat2x4h, 3>, 1>, 1>, 2>;

@group(1) @binding(37) var<storage, read_write> buffer22: array<array<array<f16, 61>, 1>>;

fn unconst_f16(v: f16) -> f16 { return v; }

@id(3948) override override1: f16;

struct FragmentInput0 {
  @location(6) @interpolate(perspective, centroid) location_6: vec2h,
}

struct ComputeInput2 {
  @builtin(local_invocation_id) local_invocation_id: vec3u,
}

fn unconst_bool(v: bool) -> bool { return v; }

@group(0) @binding(82) var<storage, read> buffer20: array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 2>, 4>;

override override3: u32;

alias vec3b = vec3<bool>;

@id(24728) override override2: i32;

var<workgroup> vw2: vec4<bool>;

struct FragmentInput1 {
  @location(13) location_13: vec2u,
}

fn unconst_i32(v: i32) -> i32 { return v; }

fn unconst_u32(v: u32) -> u32 { return v; }

/* used global variables: buffer19, buffer21, buffer22, tex7 */
@fragment
fn fragment1(a0: FragmentInput0, a1: FragmentInput1, @location(8) location_8: vec4h, @builtin(front_facing) front_facing: bool, a4: FragmentInput2) -> FragmentOutput1 {
  var out: FragmentOutput1;
  let ptr20: ptr<storage, f16, read_write> = &buffer19[arrayLength(&buffer19)][60];
  buffer22[unconst_u32(1175544312)][unconst_u32(11547822)][unconst_u32(158854629)] = buffer22[unconst_u32(661482748)][unconst_u32(450316213)][unconst_u32(80235463)];
  let ptr21: ptr<storage, array<f16, 61>, read_write> = &buffer22[arrayLength(&buffer22)][unconst_u32(177545168)];
  var vf20: vec2u = textureDimensions(tex7, unconst_i32(92790853));
  out.sample_mask = u32((*&buffer21)[1][unconst_u32(1432778498)][0][2][unconst_u32(1537722836)][0]);
  return out;
  _ = buffer21;
  _ = buffer22;
  _ = buffer19;
  _ = tex7;
}

/* used global variables: buffer19, buffer20, buffer22 */
@compute @workgroup_size(1, 1, 1)
fn compute1(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a3: ComputeInput2, @builtin(num_workgroups) num_workgroups: vec3u) {
  buffer19[u32((*&buffer20)[3][1][0][unconst_u32(268568871)][0][unconst_u32(570477539)])][unconst_u32(918579309)] = (*&buffer20)[unconst_u32(69626174)][1][0][unconst_u32(398054561)][unconst_u32(195745097)][unconst_u32(297504606)];
  let ptr22: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &buffer20[3][unconst_u32(794588800)][0];
  let ptr23: ptr<storage, f16, read_write> = &buffer19[arrayLength(&buffer19)][60];
  buffer22[unconst_u32(140315179)][unconst_u32(703020073)][unconst_u32(447818195)] = (*&buffer20)[unconst_u32(283196713)][1][u32(buffer20[unconst_u32(425449346)][unconst_u32(90996626)][unconst_u32(16637767)][0][0][0])][unconst_u32(509679854)][0][0];
  fn0(&buffer22[unconst_u32(905998896)][0]);
  fn0(&buffer22[unconst_u32(584555375)][0]);
  let ptr24: ptr<storage, array<f16, 61>, read_write> = &buffer22[unconst_u32(678557542)][0];
  let ptr25: ptr<storage, array<f16, 1>, read> = &(*&buffer20)[unconst_u32(388853099)][1][0][0][unconst_u32(1734968017)];
  fn0(&buffer22[unconst_u32(1824386796)][unconst_u32(1443169008)]);
  for (var it1=u32(buffer19[unconst_i32(-266419945)][60]); it1<(u32(buffer20[3][1][unconst_u32(511693124)][unconst_u32(439730457)][unconst_u32(666012001)][0]) & 0xfff); it1++) {
  buffer22[unconst_u32(640883336)][unconst_u32(884316598)][unconst_u32(299267521)] += (*&buffer22)[arrayLength(&(*&buffer22))][unconst_u32(572140002)][unconst_u32(2069252059)];
  atomicCompareExchangeWeak(&vw1, unconst_i32(144925476), unconst_i32(298623337));
  fn0(&(*&buffer19)[unconst_u32(323843208)]);
  atomicCompareExchangeWeak(&vw1, i32(buffer20[3][unconst_u32(2017238306)][0][0][unconst_u32(1251299439)][0]), unconst_i32(103688144));
  let ptr26: ptr<storage, f16, read> = &(*&buffer20)[3][1][0][0][0][unconst_u32(64256613)];
  switch i32(buffer20[3][1][0][0][0][0]) { 
  case 519418911, default: {
  buffer19[unconst_u32(78124638)][60] = (*&buffer20)[3][u32(buffer20[unconst_u32(229323108)][unconst_u32(482308157)][unconst_u32(487035962)][0][0][unconst_u32(2827682807)])][unconst_u32(57418669)][0][bitcast<u32>(floor(vec2h(unconst_f16(8958.7), unconst_f16(-18939.9))))][0];
  return;
  _ = buffer19;
  _ = buffer20;
}
  }
  _ = buffer22;
  _ = buffer20;
  _ = buffer19;
}
  atomicMin(&vw1, unconst_i32(45640256));
  let ptr27: ptr<storage, f16, read_write> = &buffer22[arrayLength(&buffer22)][u32(buffer19[arrayLength(&buffer19)][60])][unconst_u32(37499313)];
  _ = buffer22;
  _ = buffer20;
  _ = buffer19;
}`,
});
let commandEncoder16 = device0.createCommandEncoder({});
let promise0 = shaderModule0.getCompilationInfo();
try {
buffer11.destroy();
} catch {}
let pipeline1 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rg32uint'}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32x3', offset: 68, shaderLocation: 7},
          {format: 'unorm16x2', offset: 872, shaderLocation: 12},
          {format: 'sint8x4', offset: 12, shaderLocation: 8},
          {format: 'snorm16x4', offset: 24, shaderLocation: 6},
          {format: 'uint32x2', offset: 4, shaderLocation: 1},
          {format: 'sint32x3', offset: 552, shaderLocation: 2},
          {format: 'uint32x4', offset: 300, shaderLocation: 5},
          {format: 'float32x4', offset: 624, shaderLocation: 3},
          {format: 'unorm16x2', offset: 188, shaderLocation: 4},
          {format: 'sint16x2', offset: 436, shaderLocation: 11},
          {format: 'snorm16x2', offset: 940, shaderLocation: 14},
          {format: 'sint16x4', offset: 400, shaderLocation: 9},
          {format: 'float32', offset: 64, shaderLocation: 0},
          {format: 'sint8x4', offset: 132, shaderLocation: 10},
          {format: 'uint8x2', offset: 48, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true},
});
let buffer24 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let commandEncoder17 = device0.createCommandEncoder({});
let texture10 = device0.createTexture({
  size: {width: 80, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
device0.queue.writeBuffer(buffer24, 0, new Float16Array(14074).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.2991)), 106, 4);
} catch {}
let imageData2 = new ImageData(12, 24);
let commandEncoder18 = device0.createCommandEncoder();
let sampler1 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 66.88});
try {
renderBundleEncoder1.setIndexBuffer(buffer17, 'uint32', 32, 28);
} catch {}
let commandEncoder19 = device0.createCommandEncoder({});
let texture11 = device0.createTexture({
  size: {width: 40, height: 30, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
buffer11.unmap();
} catch {}
let texture12 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 1},
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView10 = texture9.createView({mipLevelCount: 1});
try {
renderBundleEncoder0.setVertexBuffer(0, buffer17, 88, 15);
} catch {}
try {
buffer17.unmap();
} catch {}
await gc();
let canvas1 = document.createElement('canvas');
let videoFrame2 = new VideoFrame(canvas0, {timestamp: 0});
let textureView11 = texture10.createView({label: '\u0de4\u4453\ub155\u0f58', baseArrayLayer: 0});
let textureView12 = texture5.createView({dimension: '2d-array'});
let renderPassEncoder0 = commandEncoder2.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 789.2, g: -573.4, b: 12.16, a: -274.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
commandEncoder8.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 8, y: 7, z: 0},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 1,
  origin: {x: 2, y: 27, z: 2},
  aspect: 'all',
},
{width: 23, height: 9, depthOrArrayLayers: 0});
} catch {}
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 266});
let texture13 = device0.createTexture({
  size: [120, 120, 49],
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView13 = texture6.createView({mipLevelCount: 1});
try {
renderBundleEncoder1.setVertexBuffer(1, buffer17, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 4, new DataView(new Uint8Array(14942).map((_, i) => i).buffer), 7653, 40);
} catch {}
let buffer25 = device0.createBuffer({size: 19836, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture14 = device0.createTexture({
  size: [120, 120, 49],
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder0.setIndexBuffer(buffer14, 'uint32', 0, 21);
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer12, 8, buffer15, 8, 4);
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'linear'} });
let texture15 = device0.createTexture({
  size: {width: 160, height: 120, depthOrArrayLayers: 32},
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder1 = commandEncoder3.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -803.5, g: -681.7, b: -604.7, a: 574.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 17842798,
});
try {
renderPassEncoder0.setIndexBuffer(buffer14, 'uint16', 4, 7);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData3 = new ImageData(40, 124);
let buffer26 = device0.createBuffer({
  label: '\u0e11\u0faa\u97ee\u{1fdc9}\u2e51\u0da3\u396b\u{1fd9e}\u8d6e',
  size: 132,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let textureView14 = texture15.createView({baseArrayLayer: 3, arrayLayerCount: 1});
let computePassEncoder7 = commandEncoder17.beginComputePass();
try {
renderPassEncoder0.setIndexBuffer(buffer24, 'uint32', 0, 3);
} catch {}
let texture16 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture17 = device0.createTexture({
  size: [60, 60, 19],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView15 = texture13.createView({dimension: '3d', baseMipLevel: 0});
try {
renderPassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
await gc();
let commandEncoder20 = device0.createCommandEncoder({});
let texture18 = device0.createTexture({
  size: {width: 160, height: 120, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder2 = commandEncoder11.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -237.4, g: 399.0, b: 81.99, a: -787.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 4001573,
});
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer12, 12, buffer24, 0, 0);
} catch {}
try {
  await promise0;
} catch {}
let textureView16 = texture18.createView({dimension: '2d-array'});
try {
renderBundleEncoder0.setIndexBuffer(buffer14, 'uint16', 8, 23);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline0);
} catch {}
let shaderModule2 = device0.createShaderModule({
  label: '\u6f3c\u{1f9a7}\u2cff\uf2e4\u4b57\u0dfb',
  code: `
requires unrestricted_pointer_parameters;

enable f16;

var<private> vp1: f16 = f16(18421.9);

struct T1 {
  @size(1024) f0: vec2u,
  f1: array<u32>,
}

struct VertexInput9 {
  @location(6) location_6: f16,
}

struct FragmentOutput2 {
  @builtin(sample_mask) sample_mask: u32,
  @location(1) @interpolate(flat) location_1: i32,
  @location(0) @interpolate(flat, sample) location_0: vec2u,
}

@group(1) @binding(115) var st0: texture_storage_2d<r32float, read_write>;

fn unconst_f32(v: f32) -> f32 { return v; }

fn unconst_u32(v: u32) -> u32 { return v; }

struct T2 {
  @size(256) f0: array<array<atomic<i32>, 1>, 2>,
}

/* zero global variables used */
fn fn2() {
  vp1 -= vp2[unconst_u32(229244798)];
  vp0.exp += vec3i(bitcast<i32>(clamp(unconst_f32(-0.03667e-39), faceForward(vec2f(unconst_f32(0.06426e-39), unconst_f32(0.2556e32)), vec2f(unconst_f32(0.09654e11), unconst_f32(0.3125)), vec2f(vp0.exp.gr.xy)).x, unconst_f32(-0.04058))));
  let ptr30: ptr<private, vec3f> = &vp0.fract;
  vp2 = vec2h(max(vec2u(unconst_u32(303494924), unconst_u32(1594793077)), vec2u(unconst_u32(402586177), unconst_u32(203164222))));
  vp2 = vec2h(quantizeToF16(vec2f(unconst_f32(-0.1064), unconst_f32(-0.07218e11))));
  vp2 = vec2h(tanh(vec2f(unconst_f32(0.1252e-7), unconst_f32(0.00837))).yx.xx);
  vp2 = vec2h(round(vec4f(clamp(unconst_f32(0.07622), unconst_f32(-0.2577), unconst_f32(0.1656e-20)))).xz);
  let ptr31: ptr<private, vec3f> = &(*ptr30);
}

@group(1) @binding(10) var<storage, read_write> buffer30: array<VertexInput9, 4>;

fn unconst_bool(v: bool) -> bool { return v; }

struct FragmentInput3 {
  @location(6) @interpolate(perspective, centroid) location_6: vec2h,
}

@group(0) @binding(1) var sam2: sampler_comparison;

alias vec3b = vec3<bool>;

struct VertexInput7 {
  @location(4) location_4: vec2u,
  @builtin(instance_index) instance_index: u32,
  @location(0) @interpolate(flat) location_0: i32,
  @location(12) location_12: vec2h,
  @location(10) location_10: vec2f,
}

/* used global variables: buffer27, buffer29, buffer30, buffer32, st0 */
fn fn3() {
  buffer29[unconst_u32(1555948109)][unconst_u32(366613142)][unconst_u32(149451103)][unconst_u32(1375615290)] -= vec4h((*&buffer27)[arrayLength(&(*&buffer27))][15][9][0][0]);
  var vf31 = fn0();
  let ptr32: ptr<workgroup, vec4i> = &(*&vw3)[0];
  buffer30[unconst_u32(46549400)].location_6 = f16((*&buffer32).y);
  buffer29[unconst_u32(1152183199)][u32(buffer29[arrayLength(&buffer29)][7][unconst_u32(22919597)][unconst_u32(666252676)][1])][unconst_u32(655782692)][unconst_u32(3501114111)] -= vec4h((*&buffer27)[unconst_u32(974981834)][unconst_u32(1284856752)][unconst_u32(34233959)][0][unconst_u32(178755117)]);
  var vf32 = fn0();
  var vf33 = fn0();
  _ = fn0();
  _ = fn0();
  _ = st0;
  _ = buffer32;
  _ = buffer27;
  _ = buffer29;
  _ = buffer30;
}

struct VertexInput8 {
  @location(8) location_8: vec4i,
}

@group(0) @binding(0) var<storage, read_write> buffer27: array<array<array<array<array<f16, 1>, 1>, 10>, 16>>;

var<private> vp2: vec2h = vec2h(7063.3, 1843.4);

struct VertexInput5 {
  @location(9) @interpolate(linear) location_9: vec2f,
}

/* used global variables: buffer29, st0 */
@must_use 
fn fn0() -> f32 {
  var out: f32;
  if bool(buffer29[arrayLength(&buffer29)][unconst_u32(191193553)][13][3][2]) {
  textureStore(st0, vec2i(unconst_i32(232635694), unconst_i32(865858937)), vec4f(vec4f(unconst_f32(0.2419), unconst_f32(0.00158e29), unconst_f32(0.05879), unconst_f32(0.1500e-15))));
  vp2 = buffer29[arrayLength(&buffer29)][7][13][3].yw;
  _ = buffer29;
  _ = st0;
}
  return out;
  _ = buffer29;
  _ = st0;
}

struct T0 {
  f0: array<atomic<i32>>,
}

struct T3 {
  f0: array<f16>,
}

@group(2) @binding(10) var<storage, read_write> buffer32: vec2i;

fn unconst_f16(v: f16) -> f16 { return v; }

var<private> vp0 = frexp(vec3f(-0.06540, 0.3073e17, 0.2877e2));

struct T4 {
  @size(128) f0: f16,
  f1: array<array<vec2f, 20>, 1>,
  @size(32) f2: vec4u,
  @size(32) f3: vec4<bool>,
  @size(2688) f4: array<vec4h, 3>,
  @size(1024) f5: array<array<array<array<array<vec2i, 1>, 1>, 1>, 1>, 64>,
}

@group(1) @binding(0) var<storage, read_write> buffer29: array<array<array<array<vec4h, 4>, 14>, 8>>;

struct VertexInput6 {
  @location(2) @interpolate(flat) location_2: vec2h,
}

var<workgroup> vw3: array<vec4i, 1>;

/* used global variables: sam2 */
fn fn1(a0: ptr<private, vec3f>) -> vec4h {
  var out: vec4h;
  let ptr28 = &vp0;
  let vf21: vec3u = countOneBits(vec3u(unconst_u32(453479565), unconst_u32(200111916), unconst_u32(37416292)));
  (*a0) *= vec3f(vp0.exp.yzz);
  while bool(degrees(bitcast<vec3f>((vec2i(unconst_i32(854364612), unconst_i32(123051469)) + vec2i(unconst_i32(269926071), unconst_i32(688283799))).yyy.rgg.rrr.gbg.zxz.zxz.rbb)).z) {
  let vf22: vec4f = trunc(vec4f(unconst_f32(0.1529e-25), unconst_f32(0.03220e-21), unconst_f32(-0.1198), unconst_f32(0.04839e37)));
  vp0 = frexp(round(vec2f(f32((unconst_bool(false) || unconst_bool(true))))).grr);
  for (var it2=(vec2u(unconst_u32(897733088), unconst_u32(965774378)) & vec2u(unconst_u32(828734767), unconst_u32(624299609))).y; it2<(u32(out[unconst_u32(197195416)]) & 0xfff); it2++) {
  _ = sam2;
  let vf23: vec3f = refract(vec3f(unconst_f32(-0.6778), unconst_f32(0.4164), unconst_f32(0.4305)), vec3f(unconst_f32(0.05847), unconst_f32(0.7175e18), unconst_f32(0.06871e-1)), unconst_f32(0.04104));
  let vf24: vec3i = firstTrailingBit(vec3i(unconst_i32(-1867443052), unconst_i32(193512815), unconst_i32(1075053501)));
  vp2 *= bitcast<vec2h>(vf24[unconst_u32(1402734055)]);
  return out;
  _ = sam2;
}
  let ptr29: ptr<private, vec3f> = &vp0.fract;
  (*a0) = vec3f(f32(pack4xU8(vec4u(unconst_u32(113505820), unconst_u32(528675951), unconst_u32(418208162), unconst_u32(634273978)))));
  let vf25: vec3f = fma(vec3f(f32(pack4xU8Clamp(vec4u(unconst_u32(343627469), unconst_u32(601814029), unconst_u32(93839860), unconst_u32(1762935749))))), vec3f(unconst_f32(0.01339e-45), unconst_f32(0.4619e33), unconst_f32(0.09793)), trunc(vec4f(unconst_f32(0.04910e-36), unconst_f32(0.00168), unconst_f32(0.3529e12), unconst_f32(0.01230e-34))).grb);
  _ = sam2;
}
  let vf26: f32 = degrees(unconst_f32(0.01067));
  var vf27: vec2i = (vec2i(unconst_i32(354973367), unconst_i32(90071641)) + vec2i(unconst_i32(49895896), unconst_i32(-261152576)));
  let vf28: vec2f = asin(vec2f(unconst_f32(0.3498e28), unconst_f32(0.5207)));
  let vf29: vec4i = countOneBits(vec4i(unconst_i32(323079888), unconst_i32(-45250794), unconst_i32(86303850), unconst_i32(1023273626)));
  let vf30: f32 = log2(unconst_f32(-0.1092e-9));
  return out;
  _ = sam2;
}

struct T5 {
  f0: array<atomic<i32>>,
}

fn unconst_i32(v: i32) -> i32 { return v; }

struct VertexOutput1 {
  @builtin(position) position: vec4f,
  @location(11) location_11: vec4u,
  @location(9) @interpolate(flat, center) location_9: vec2f,
  @location(6) @interpolate(perspective, first) location_6: vec4f,
  @location(5) location_5: vec4h,
  @location(4) location_4: f16,
  @location(3) location_3: vec2f,
}

/* used global variables: sam2 */
@vertex
fn vertex1(@builtin(vertex_index) vertex_index: u32, a1: VertexInput5, a2: VertexInput6, @location(11) @interpolate(flat, sample) location_11: vec2i, @location(5) @interpolate(flat) location_5: vec4u, a5: VertexInput7, @location(13) location_13: f16, @location(14) location_14: vec4i, a8: VertexInput8, a9: VertexInput9, @location(3) @interpolate(flat, centroid) location_3: i32, @location(1) @interpolate(flat, center) location_1: vec2i) -> VertexOutput1 {
  var out: VertexOutput1;
  let vf34: f16 = tanh(unconst_f16(18839.6));
  {
  _ = fn1(&vp0.fract);
  var vf35: i32 = a8.location_8[unconst_u32(1079192223)];
  let ptr33 = &vp0;
  switch bitcast<u32>(a5.location_0) { 
  case default: {
  let vf36: vec2u = a5.location_4;
  out.position *= sqrt(vec3f(unconst_f32(0.02753), unconst_f32(0.01764e28), unconst_f32(0.4663e10))).bggb;
  var vf37 = fn1(&vp0.fract);
  var vf38: vec2i = (i32(sign(vec3h(unconst_f16(20314.6), unconst_f16(18100.8), unconst_f16(2831.9)))[1]) - vec2i(unconst_i32(-698780598), unconst_i32(-133736147)));
  break;
  _ = sam2;
}
  }
  out.location_6 += vec4f(f32(a9.location_6));
  while bool(a5.location_12.x) {
  out.location_3 = a5.location_10;
  fn1(&vp0.fract);
  var vf39: u32 = a5.instance_index;
  out.location_3 -= vec2f(bitcast<f32>(location_1[unconst_u32(227553505)]));
  return out;
  _ = sam2;
}
  _ = sam2;
}
  fn1(&vp0.fract);
  {
  let vf40: vec4f = unpack4x8unorm(unconst_u32(106274606));
  let ptr34: ptr<function, f16> = &out.location_4;
  let vf41: f32 = out.location_6[unconst_u32(274690937)];
  vp0 = frexp(vec3f(f32(countTrailingZeros(vec4i(out.location_5)[1]))));
  fn2();
  var vf42: i32 = location_11[unconst_u32(520634253)];
}
  out.position = unpack4x8snorm(countTrailingZeros(unconst_u32(981962243)));
  out.location_6 *= vec4f(f32(a5.location_0));
  out.location_3 = vec2f(vec2f(f32(trunc(unconst_f16(6403.5)))));
  return out;
  _ = sam2;
}

/* used global variables: buffer29, st0 */
@fragment
fn fragment2(a0: FragmentInput3) -> FragmentOutput2 {
  var out: FragmentOutput2;
  out.location_1 = i32(buffer29[arrayLength(&buffer29)][7][unconst_u32(1024409941)][3][unconst_u32(218140859)]);
  _ = fn0();
  return out;
  _ = buffer29;
  _ = st0;
}

/* used global variables: buffer27, buffer29, buffer30, buffer32, st0 */
@compute @workgroup_size(2, 1, 2)
fn compute2(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(local_invocation_id) local_invocation_id: vec3u) {
  let ptr35: ptr<storage, vec4h, read_write> = &(*&buffer29)[unconst_u32(1078733529)][7][unconst_u32(1234377594)][3];
  fn3();
  _ = buffer32;
  _ = buffer27;
  _ = buffer29;
  _ = st0;
  _ = buffer30;
}`,
});
try {
renderPassEncoder2.setIndexBuffer(buffer14, 'uint32', 4, 3);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline0);
} catch {}
try {
  await buffer26.mapAsync(GPUMapMode.READ, 0, 16);
} catch {}
document.body.append(canvas1);
let texture19 = device0.createTexture({size: [120], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST});
try {
renderBundleEncoder1.setIndexBuffer(buffer24, 'uint32', 0, 3);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(3, buffer17, 0, 122);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
document.body.prepend(canvas0);
document.body.prepend(canvas1);
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'bt709'} });
let renderPassEncoder3 = commandEncoder15.beginRenderPass({colorAttachments: [{view: textureView10, loadOp: 'load', storeOp: 'store'}]});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1, depthReadOnly: true});
try {
renderPassEncoder1.setVertexBuffer(2, buffer17);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(4, buffer17, 0, 136);
} catch {}
try {
buffer24.unmap();
} catch {}
try {
commandEncoder8.resolveQuerySet(querySet0, 9, 127, buffer25, 1280);
} catch {}
await gc();
let commandEncoder21 = device0.createCommandEncoder({});
try {
renderBundleEncoder0.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 48, new Uint32Array(8741).map((_, i) => i * 2), 1644, 4);
} catch {}
let renderPassEncoder4 = commandEncoder21.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -14.01, g: -345.0, b: -363.8, a: -194.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 212298139,
});
await gc();
let texture20 = device0.createTexture({
  size: [30, 30, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder5 = commandEncoder16.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 311.3, g: -139.3, b: 87.15, a: -897.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 553448143,
});
try {
renderPassEncoder4.beginOcclusionQuery(24);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
buffer0.unmap();
} catch {}
let buffer35 = device0.createBuffer({size: 52, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let commandEncoder22 = device0.createCommandEncoder();
let texture21 = device0.createTexture({
  size: {width: 40, height: 30, depthOrArrayLayers: 3},
  mipLevelCount: 2,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
device0.queue.writeBuffer(buffer24, 0, new Uint32Array(1101).map((_, i) => i * 6), 327, 0);
} catch {}
let textureView17 = texture13.createView({baseArrayLayer: 0});
let renderPassEncoder6 = commandEncoder5.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 982.1, g: 895.6, b: 627.8, a: 4.370, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
let sampler2 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', minFilter: 'nearest', compare: 'greater'});
try {
renderBundleEncoder2.setPipeline(pipeline1);
} catch {}
let commandEncoder23 = device0.createCommandEncoder();
let textureView18 = texture0.createView({dimension: 'cube', baseArrayLayer: 1, arrayLayerCount: 6});
try {
renderBundleEncoder0.setVertexBuffer(3, buffer17, 16);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
document.body.append(canvas0);
let commandEncoder24 = device0.createCommandEncoder({});
try {
renderPassEncoder2.setIndexBuffer(buffer24, 'uint32', 0, 1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer17, 44, 28);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
renderBundleEncoder2.insertDebugMarker('\uca88');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext1 = canvas1.getContext('webgpu');
let shaderModule3 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

enable f16;

struct T2 {
  f0: array<f16>,
}

struct VertexInput11 {
  @location(12) @interpolate(flat) location_12: vec4f,
  @location(15) @interpolate(flat, centroid) location_15: f16,
}

@group(3) @binding(3) var et8: texture_external;

struct VertexOutput2 {
  @location(6) location_6: vec4f,
  @location(1) location_1: f16,
  @location(8) location_8: vec4f,
  @location(14) @interpolate(perspective, either) location_14: f32,
  @location(7) location_7: f32,
  @location(0) @interpolate(flat, sample) location_0: vec2u,
  @location(13) location_13: vec2f,
  @location(10) @interpolate(flat, first) location_10: vec2u,
  @location(2) @interpolate(flat, sample) location_2: vec4f,
  @location(9) location_9: vec4h,
  @location(11) @interpolate(flat, sample) location_11: vec4i,
  @builtin(position) position: vec4f,
}

struct FragmentInput4 {
  @location(8) location_8: vec4h,
}

@group(2) @binding(70) var<uniform> buffer42: array<vec4f, 16>;

var<workgroup> vw4: array<f16, 56>;

/* used global variables: buffer40, buffer44, et9 */
fn fn1(a0: vec4<bool>) -> array<array<array<vec2f, 2>, 1>, 13> {
  var out: array<array<array<vec2f, 2>, 1>, 13>;
  for (var jj1=0u; jj1<15; jj1++) { out[jj1][unconst_u32(1207139300)][unconst_u32(865478813)] += bitcast<vec2f>(buffer40[5].gr.rr); }
  for (var jj93=0u; jj93<15; jj93++) { for (var jj30=0u; jj30<3; jj30++) { for (var jj46=0u; jj46<4; jj46++) { out[jj93][jj30][jj46] = bitcast<vec2f>(buffer44[5][0][0].location_0.xx.gg); } } }
  let vf51: vec2h = step(bitcast<vec2h>(pack2x16unorm(vec2f(unconst_f32(0.09517), unconst_f32(0.1252)))), vec2h(buffer44[5][0][unconst_u32(1875665462)].location_0.xx));
  var vf52: u32 = buffer44[unconst_u32(1410080336)][0][(*&buffer44)[5][0][0].location_0[3]].location_0[unconst_u32(1311032058)];
  let ptr42: ptr<uniform, array<array<FragmentOutput3, 1>, 1>> = &buffer44[5];
  let ptr43: ptr<function, array<vec2f, 2>> = &out[12][unconst_u32(381239132)];
  let ptr44: ptr<uniform, FragmentOutput3> = &(*&buffer44)[5][0][unconst_u32(3421915001)];
  vf52 = pack4x8unorm(textureLoad(et9, vec2u(unconst_u32(192767892), unconst_u32(837880190))));
  vf52 >>= (*&buffer44)[5][0][unconst_u32(1120245654)].location_0[unconst_u32(775220954)];
  var vf53: u32 = buffer44[unconst_u32(488962909)][buffer44[5][bitcast<vec2u>((*ptr43)[1].xx.gg).g][unconst_u32(1799093319)].location_0[3]][0].location_0[unconst_u32(3906691)];
  return out;
  _ = et9;
  _ = buffer40;
  _ = buffer44;
}

@group(1) @binding(3) var et6: texture_external;

var<workgroup> vw5: atomic<u32>;

fn unconst_bool(v: bool) -> bool { return v; }

@group(1) @binding(0) var tex8: texture_cube_array<f32>;

struct VertexInput12 {
  @location(8) location_8: u32,
  @location(2) @interpolate(flat, first) location_2: vec4h,
  @location(5) @interpolate(flat, either) location_5: f16,
  @location(10) location_10: vec4u,
  @builtin(instance_index) instance_index: u32,
  @location(14) location_14: u32,
  @location(13) location_13: vec4u,
}

struct FragmentOutput3 {
  @location(0) location_0: vec4u,
}

var<workgroup> vw6: bool;

@group(3) @binding(436) var et9: texture_external;

struct T1 {
  @align(16) f0: array<array<atomic<u32>, 24>>,
}

struct VertexInput14 {
  @location(1) @interpolate(flat, center) location_1: vec2i,
}

@group(3) @binding(144) var<uniform> buffer44: array<array<array<FragmentOutput3, 1>, 1>, 6>;

struct T0 {
  @size(122) f0: vec4f,
}

struct ComputeInput4 {
  @builtin(num_workgroups) num_workgroups: vec3u,
  @builtin(workgroup_id) workgroup_id: vec3u,
}

@group(2) @binding(0) var<storage, read_write> buffer41: array<array<array<array<VertexInput10, 8>, 1>, 5>>;

@group(1) @binding(37) var<storage, read_write> buffer38: array<f16, 61>;

struct ComputeInput3 {
  @builtin(local_invocation_index) local_invocation_index: u32,
}

/* used global variables: buffer38, et6, et9, tex10, tex8 */
fn fn0(a0: ptr<workgroup, atomic<u32>>) -> vec2h {
  var out: vec2h;
  let vf43: vec2u = textureDimensions(et6);
  {
  if bool(textureDimensions(tex10).y) {
  buffer38[unconst_u32(648400216)] = f16(pack4xI8Clamp(vec4i(unconst_i32(4089361), unconst_i32(230914195), unconst_i32(321286034), unconst_i32(261159969))));
  let ptr36: ptr<workgroup, atomic<u32>> = &(*a0);
  let ptr37: ptr<function, vec2h> = &out;
  let ptr38: ptr<storage, f16, read_write> = &buffer38[unconst_u32(371976774)];
  _ = buffer38;
}
  out = bitcast<vec2h>(atomicLoad(&(*a0)));
  let ptr39: ptr<workgroup, atomic<u32>> = &(*a0);
  return out;
  _ = tex10;
  _ = buffer38;
}
  var vf44: vec2f = unpack2x16unorm(unconst_u32(1382999521));
  let ptr40: ptr<storage, f16, read_write> = &(*&buffer38)[60];
  vf44 *= vec2f(textureDimensions(et9));
  atomicMax(&(*a0), u32(tanh(unconst_f16(7216.5))));
  out = vec2h((vec3u(unconst_u32(867892588), unconst_u32(152479738), unconst_u32(1277173755)) ^ vec3u(unconst_u32(1536577019), unconst_u32(368837568), unconst_u32(446186716))).zx.xy.gg.yx.yx.xy);
  while bool((vec3u(unconst_u32(426234311), unconst_u32(2046218800), unconst_u32(1709969126)) ^ vec3u(unconst_u32(612414100), unconst_u32(204648490), unconst_u32(3937474598)))[2]) {
  let ptr41: ptr<storage, f16, read_write> = &(*&buffer38)[60];
  let vf45: ptr<storage, array<f16, 61>, read_write> = &buffer38;
  atomicAdd(&(*a0), unconst_u32(602235563));
  atomicMax(&(*a0), unconst_u32(1538649860));
  out = vec2h((*&buffer38)[unconst_u32(430599921)]);
  _ = buffer38;
}
  for (var it3=countTrailingZeros(vec2u(unconst_u32(134785262), unconst_u32(651867600)))[1]; it3<(textureNumLevels(tex8) & 0xfff); it3++) {
  {
  out = vec2h(textureDimensions(tex10, unconst_i32(-195099476)).yx);
  let vf46: vec2u = textureDimensions(tex8);
  out -= vec2h(textureDimensions(tex8));
  break;
  _ = tex8;
  _ = tex10;
}
  let vf47: vec3u = extractBits(vec3u(out.yxx), unconst_u32(784130928), unconst_u32(333678387));
  _ = tex8;
  _ = tex10;
}
  let vf48: vec2f = abs(vec2f(unconst_f32(0.2817), unconst_f32(0.1450e14)));
  loop {
  let vf49: vec2f = (unconst_f32(0.08741e25) + vec2f(unconst_f32(0.03089e-35), unconst_f32(0.01487)));
  buffer38[unconst_u32(1662575162)] = vec2h(textureDimensions(et9))[0];
  var vf50: u32 = pack4xI8Clamp(vec4i(unconst_i32(226018745), unconst_i32(-613857408), unconst_i32(800569), unconst_i32(540364504)));
  _ = et6;
  break;
  _ = et6;
  _ = et9;
  _ = buffer38;
}
  return out;
  _ = buffer38;
  _ = et9;
  _ = tex8;
  _ = et6;
  _ = tex10;
}

@id(30159) override override5: i32 = 208883;

fn unconst_f16(v: f16) -> f16 { return v; }

@group(0) @binding(0) var<storage, read_write> buffer36: array<array<array<f16, 5>, 4>, 8>;

struct VertexInput10 {
  @builtin(vertex_index) vertex_index: u32,
  @location(4) @interpolate(perspective, centroid) location_4: f16,
}

@group(0) @binding(70) var<uniform> buffer37: array<array<array<array<vec4u, 2>, 1>, 8>, 1>;

@group(3) @binding(0) var tex10: texture_cube_array<f32>;

struct VertexInput13 {
  @location(9) @interpolate(flat, sample) location_9: vec2i,
}

fn unconst_u32(v: u32) -> u32 { return v; }

fn unconst_f32(v: f32) -> f32 { return v; }

@group(1) @binding(144) var<uniform> buffer40: array<vec4i, 6>;

fn unconst_i32(v: i32) -> i32 { return v; }

/* used global variables: buffer40, buffer44, et9 */
@vertex
fn vertex2(@location(7) @interpolate(flat, either) location_7: vec4u, a1: VertexInput10, a2: VertexInput11, @location(0) @interpolate(linear, centroid) location_0: vec2h, @location(3) @interpolate(linear, center) location_3: f16, a5: VertexInput12, a6: VertexInput13, @location(11) @interpolate(flat) location_11: vec2u, a8: VertexInput14, @location(6) location_6: vec2i) -> VertexOutput2 {
  var out: VertexOutput2;
  out.location_11 -= vec4i(i32(out.location_1));
  out.location_2 = bitcast<vec4f>(buffer40[unconst_u32(630106820)].yzyw.xywy.ragb.agbb.wywz.bgrg);
  out.position = vec4f(buffer40[5].xxyw.aarr);
  var vf54 = fn1(vec4<bool>(bool(a5.location_14)));
  out.location_6 = bitcast<vec4f>(location_11.yyxy);
  var vf55 = fn1(vec4<bool>(out.location_0.xxxx));
  out.location_1 = f16((*&buffer44)[5][unconst_u32(100938322)][unconst_u32(214716301)].location_0.x);
  let ptr45: ptr<function, vec4f> = &out.location_6;
  return out;
  _ = et9;
  _ = buffer44;
  _ = buffer40;
}

/* used global variables: buffer37, buffer38, buffer42, buffer44 */
@fragment
fn fragment3(a0: FragmentInput4) -> FragmentOutput3 {
  var out: FragmentOutput3;
  buffer38[unconst_u32(212015240)] = f16((*&buffer37)[unconst_u32(208428873)][7][0][unconst_u32(916697559)][unconst_u32(1684433763)]);
  buffer38[unconst_u32(341902626)] = vec4h(buffer42[15].yxxz).a;
  let ptr46: ptr<uniform, vec4u> = &(*&buffer44)[unconst_u32(1127137096)][0][unconst_u32(361852802)].location_0;
  let ptr47: ptr<uniform, vec4u> = &buffer44[5][unconst_u32(809668812)][0].location_0;
  while bool((*&buffer44)[5][0][0].location_0[unconst_u32(127901613)]) {
  out.location_0 &= vec4u(asinh(vec2h(unconst_f16(25048.0), unconst_f16(6299.3))).xyxx.rara);
  if bool((*&buffer37)[pack4xU8(buffer37[0][7][unconst_u32(1246302121)][1])][unconst_u32(922255604)][0][1].a) {
  let ptr48: ptr<uniform, array<array<vec4u, 2>, 1>> = &buffer37[0][unconst_u32(1107803129)];
  buffer38[unconst_u32(225811010)] += sin(vec2h(unconst_f16(2961.0), unconst_f16(1017.8))).x;
  break;
  _ = buffer38;
  _ = buffer37;
}
  break;
  _ = buffer37;
  _ = buffer38;
}
  let ptr49: ptr<uniform, array<vec4u, 2>> = &buffer37[0][unconst_u32(1233077003)][unconst_u32(1017975539)];
  buffer38[unconst_u32(746446156)] *= f16(pack4xU8Clamp((*&buffer37)[0][unconst_u32(749824216)][0][1]));
  out.location_0 = (*&buffer37)[0][unconst_u32(969736343)][unconst_u32(1462673959)][1];
  buffer38[60] = f16((*&buffer37)[0][7][unconst_u32(164308077)][1].a);
  let ptr50: ptr<uniform, vec4f> = &(*&buffer42)[unconst_u32(392253200)];
  return out;
  _ = buffer37;
  _ = buffer44;
  _ = buffer38;
  _ = buffer42;
}

/* used global variables: buffer36, buffer38, buffer41, et6, et8, et9, tex10, tex8 */
@compute @workgroup_size(1, 1, 1)
fn compute3(a0: ComputeInput3, @builtin(local_invocation_id) local_invocation_id: vec3u, a2: ComputeInput4, @builtin(global_invocation_id) global_invocation_id: vec3u) {
  atomicCompareExchangeWeak(&vw5, unconst_u32(399197368), unconst_u32(390179032));
  fn0(&vw5);
  let ptr51: ptr<storage, f16, read_write> = &(*&buffer41)[unconst_u32(4763469)][4][unconst_u32(764815513)][7].location_4;
  var vf56 = fn0(&vw5);
  let vf57: vec2u = textureDimensions(et8);
  let ptr52: ptr<storage, VertexInput10, read_write> = &buffer41[unconst_u32(513747369)][unconst_u32(2734192421)][0][7];
  {
  vw6 = bool((*&buffer41)[arrayLength(&(*&buffer41))][unconst_u32(394380768)][unconst_u32(261082616)][7].vertex_index);
  let ptr53: ptr<storage, array<array<f16, 5>, 4>, read_write> = &(*&buffer36)[7];
  atomicXor(&vw5, unconst_u32(2229750419));
  let ptr54: ptr<storage, VertexInput10, read_write> = &(*&buffer41)[unconst_u32(645036444)][4][(*&buffer41)[unconst_u32(8273960)][4][0][7].vertex_index][7];
  atomicAdd(&vw5, u32(buffer41[unconst_u32(752972542)][unconst_u32(75355002)][0][7].location_4));
  buffer36[unconst_u32(876405732)][unconst_u32(460114815)][unconst_u32(450831075)] = f16(round(vec2f(unconst_f32(0.03934), unconst_f32(0.1212e28))).g);
  _ = buffer41;
  _ = buffer36;
}
  fn0(&(*&vw5));
  _ = buffer41;
  _ = tex8;
  _ = et9;
  _ = et8;
  _ = et6;
  _ = buffer36;
  _ = tex10;
  _ = buffer38;
}`,
});
let buffer45 = device0.createBuffer({size: 76, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder25 = device0.createCommandEncoder({});
let texture22 = device0.createTexture({size: [40], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST});
let renderPassEncoder7 = commandEncoder19.beginRenderPass({
  label: '\u0563\u3478\ub550\u3b5c',
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 996.7, g: 583.3, b: -419.3, a: 349.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder5.setIndexBuffer(buffer14, 'uint32', 0, 7);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline0);
} catch {}
let commandEncoder26 = device0.createCommandEncoder();
let texture23 = device0.createTexture({
  size: [30],
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderBundleEncoder0.setIndexBuffer(buffer15, 'uint16', 2, 25);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 2 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder27 = device0.createCommandEncoder({});
let texture24 = device0.createTexture({
  size: [60, 60, 1],
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture25 = device0.createTexture({
  size: [40, 30, 165],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder3.setVertexBuffer(4, buffer17, 12, 14);
} catch {}
let sampler3 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 70.95,
});
try {
renderBundleEncoder2.setVertexBuffer(2, buffer45, 0, 1);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
let querySet1 = device0.createQuerySet({type: 'timestamp', count: 174});
let texture26 = device0.createTexture({
  size: {width: 40, height: 30, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder8 = commandEncoder22.beginComputePass();
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1});
let buffer46 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let texture27 = device0.createTexture({
  size: [30, 30, 1],
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder9 = commandEncoder25.beginComputePass();
try {
renderBundleEncoder0.setIndexBuffer(buffer14, 'uint32', 20, 10);
} catch {}
await gc();
let textureView19 = texture8.createView({aspect: 'all'});
let sampler4 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat'});
try {
renderPassEncoder2.setVertexBuffer(2, buffer45, 0);
} catch {}
try {
buffer15.unmap();
} catch {}
try {
commandEncoder23.insertDebugMarker('\u0736');
} catch {}
let externalTexture0 = device0.importExternalTexture({source: videoFrame4});
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 14},
  aspect: 'all',
}, new Uint8Array(2_396).fill(86), /* required buffer size: 2_396 */
{offset: 246, bytesPerRow: 34, rowsPerImage: 21}, {width: 1, height: 1, depthOrArrayLayers: 4});
} catch {}
try {
adapter0.label = '\u464b\u041f\u84cf\u0551\ubbd3\ufdd9\u706e\u{1f9e0}\u0642\u022f\u{1feb5}';
} catch {}
let texture28 = device0.createTexture({
  size: {width: 160, height: 120, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView20 = texture4.createView({});
let renderPassEncoder8 = commandEncoder13.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -891.8, g: 810.5, b: -112.8, a: -119.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 657869832,
});
try {
commandEncoder7.clearBuffer(buffer11);
} catch {}
try {
device0.queue.writeBuffer(buffer24, 4, new Uint32Array(5866).map((_, i) => i * 6), 1038, 0);
} catch {}
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true});
try {
renderPassEncoder7.beginOcclusionQuery(216);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: 195.9, g: -44.76, b: 797.5, a: 1.332, });
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer45.unmap();
} catch {}
document.body.prepend(canvas1);
let commandEncoder28 = device0.createCommandEncoder({});
try {
renderBundleEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer17, 0, 129);
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas0);
let textureView21 = texture21.createView({aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder10 = commandEncoder23.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
renderPassEncoder5.setBlendConstant({ r: -563.7, g: 159.8, b: -262.2, a: -509.0, });
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer45, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 1, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer12, 'uint16', 2, 40);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer17);
} catch {}
await gc();
let renderPassEncoder9 = commandEncoder8.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 914.0, g: 936.9, b: -825.4, a: -11.98, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 212092270,
});
let sampler5 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.71,
  compare: 'not-equal',
  maxAnisotropy: 14,
});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer47 = device0.createBuffer({size: 76, usage: GPUBufferUsage.INDEX});
let renderPassEncoder10 = commandEncoder14.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -482.3, g: 614.6, b: -386.0, a: 922.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 118, endOfPassWriteIndex: 81},
});
try {
  await promise2;
} catch {}
let commandEncoder29 = device0.createCommandEncoder({});
let computePassEncoder11 = commandEncoder28.beginComputePass();
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer17, 'uint16', 40, 27);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer45, 0, 29);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let textureView22 = texture27.createView({});
try {
renderBundleEncoder0.setPipeline(pipeline1);
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 1, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 64,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 630,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let buffer48 = device0.createBuffer({
  size: 60,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder30 = device0.createCommandEncoder({});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true});
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer47, 'uint16', 12, 4);
} catch {}
let buffer49 = device0.createBuffer({size: 80, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder10.setVertexBuffer(0, buffer17, 0, 12);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer14, 'uint32', 0, 10);
} catch {}
try {
commandEncoder20.clearBuffer(buffer26);
} catch {}
try {
globalThis.someLabel = buffer35.label;
} catch {}
let bindGroup0 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 1, resource: externalTexture0},
    {binding: 64, resource: textureView15},
    {binding: 0, resource: {buffer: buffer49}},
    {binding: 630, resource: textureView16},
    {binding: 4, resource: textureView14},
  ],
});
let buffer50 = device0.createBuffer({
  size: 17,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder31 = device0.createCommandEncoder({});
let texture29 = device0.createTexture({
  size: {width: 60, height: 60, depthOrArrayLayers: 211},
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true});
try {
computePassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(1114), 108, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer17, 'uint16', 40, 18);
} catch {}
let imageData4 = new ImageData(28, 24);
let commandEncoder32 = device0.createCommandEncoder();
try {
computePassEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(168), 95, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup0, new Uint32Array(1450), 176, 0);
} catch {}
let arrayBuffer0 = buffer48.getMappedRange(8, 20);
try {
commandEncoder24.copyBufferToBuffer(buffer17, 32, buffer24, 0, 4);
} catch {}
let buffer51 = device0.createBuffer({size: 28, usage: GPUBufferUsage.COPY_SRC});
let texture30 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 82},
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32uint'],
});
try {
computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(6200), 527, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(851), 165, 0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(5, buffer17, 0, 7);
} catch {}
try {
buffer50.unmap();
} catch {}
let texture31 = device0.createTexture({
  size: [160, 120, 1],
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let texture32 = gpuCanvasContext0.getCurrentTexture();
try {
renderPassEncoder10.setVertexBuffer(6, buffer50, 0, 1);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(752), 164, 0);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer14, 'uint16', 2, 2);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer17, 8);
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\u0c5e');
} catch {}
let buffer52 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']});
let externalTexture1 = device0.importExternalTexture({label: '\u{1fb06}\u5660\uc055\ub01e\uec50', source: videoFrame4});
try {
renderPassEncoder7.setIndexBuffer(buffer17, 'uint32', 8, 36);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer50, 4);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(2496), 71, 0);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(5, buffer48, 16);
} catch {}
let autogeneratedBindGroupLayout0 = pipeline1.getBindGroupLayout(0);
let textureView23 = texture1.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder12 = commandEncoder27.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 84, endOfPassWriteIndex: 159}});
let sampler6 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.33,
  maxAnisotropy: 10,
});
try {
renderPassEncoder5.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer49, 'uint32', 52, 4);
} catch {}
let buffer53 = device0.createBuffer({
  size: 112,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder33 = device0.createCommandEncoder({});
let texture33 = device0.createTexture({
  size: {width: 160, height: 120, depthOrArrayLayers: 46},
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder13 = commandEncoder7.beginComputePass();
let renderPassEncoder11 = commandEncoder20.beginRenderPass({
  colorAttachments: [{view: textureView10, loadOp: 'clear', storeOp: 'store'}],
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 152},
  maxDrawCount: 31019685,
});
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
let promise3 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
let commandEncoder34 = device0.createCommandEncoder({});
let textureView24 = texture24.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder6.beginOcclusionQuery(91);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
globalThis.someLabel = computePassEncoder7.label;
} catch {}
let texture34 = device0.createTexture({
  size: [15, 15, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder12 = commandEncoder33.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -289.1, g: -962.4, b: -726.3, a: 3.698, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(536), 62, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder35 = device0.createCommandEncoder();
let textureView25 = texture7.createView({mipLevelCount: 1});
let renderPassEncoder13 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -981.5, g: -99.06, b: -688.9, a: 179.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 78},
  maxDrawCount: 332164894,
});
try {
computePassEncoder7.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer47, 'uint32', 32, 7);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline0);
} catch {}
let arrayBuffer1 = buffer48.getMappedRange(0, 0);
try {
  await promise1;
} catch {}
let videoFrame5 = videoFrame3.clone();
let commandEncoder36 = device0.createCommandEncoder({});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true});
try {
computePassEncoder9.setBindGroup(2, bindGroup0, new Uint32Array(305), 260, 0);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(74);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer17, 0, 68);
} catch {}
let imageData5 = new ImageData(56, 32);
let commandEncoder37 = device0.createCommandEncoder();
let textureView26 = texture18.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder11.setBindGroup(1, bindGroup0, new Uint32Array(2648), 1_141, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer15, 'uint16', 16, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 20, z: 12},
  aspect: 'all',
}, new Uint8Array(87_992).fill(180), /* required buffer size: 87_992 */
{offset: 302, bytesPerRow: 139, rowsPerImage: 31}, {width: 30, height: 11, depthOrArrayLayers: 21});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
computePassEncoder6.label = '\u2ac8\u071b\u05c8\uf771\u0aab\u{1fe74}\u{1ff24}\u5773\uc2a2';
} catch {}
let buffer54 = device0.createBuffer({size: 780, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView27 = texture27.createView({dimension: '2d-array'});
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 20, new Uint16Array(7921).map((_, i) => i + 5), 3996, 4);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer55 = device0.createBuffer({
  size: 48,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
try {
renderBundleEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(2413), 909, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer24, 'uint16', 6, 2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 35},
  aspect: 'all',
}, new Uint8Array(41_924).fill(107), /* required buffer size: 41_924 */
{offset: 58, bytesPerRow: 75, rowsPerImage: 15}, {width: 2, height: 4, depthOrArrayLayers: 38});
} catch {}
try {
computePassEncoder11.setBindGroup(3, bindGroup0, new Uint32Array(611), 224, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(657), 113, 0);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await promise4;
} catch {}
let textureView28 = texture0.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2});
let computePassEncoder14 = commandEncoder34.beginComputePass();
try {
computePassEncoder9.setBindGroup(0, bindGroup0, new Uint32Array(1152), 38, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer12, 'uint16', 8, 39);
} catch {}
let bindGroup1 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 630, resource: textureView16},
    {binding: 64, resource: textureView17},
    {binding: 0, resource: {buffer: buffer53, size: 16}},
    {binding: 4, resource: textureView14},
    {binding: 1, resource: externalTexture1},
  ],
});
let commandEncoder38 = device0.createCommandEncoder();
let renderPassEncoder14 = commandEncoder37.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -296.8, g: -244.6, b: 633.6, a: 642.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 137, endOfPassWriteIndex: 100},
  maxDrawCount: 107043970,
});
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(77).fill(220), /* required buffer size: 77 */
{offset: 77}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture35 = device0.createTexture({
  size: [160, 120, 661],
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder15 = commandEncoder29.beginRenderPass({colorAttachments: [{view: textureView10, loadOp: 'clear', storeOp: 'discard'}]});
try {
renderPassEncoder15.setVertexBuffer(1, buffer48, 4, 0);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer17, 'uint16', 48, 7);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline0);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(22); };
} catch {}
document.body.append(canvas0);
let commandEncoder39 = device0.createCommandEncoder({});
let texture36 = device0.createTexture({
  size: [160],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder3.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline1);
} catch {}
document.body.prepend(canvas1);
let commandEncoder40 = device0.createCommandEncoder({});
let textureView29 = texture35.createView({dimension: '3d', aspect: 'all'});
let textureView30 = texture33.createView({baseArrayLayer: 7, arrayLayerCount: 2});
let sampler7 = device0.createSampler({compare: 'less-equal'});
let externalTexture2 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder13.setBindGroup(3, bindGroup0, new Uint32Array(1662), 429, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer15, 'uint16', 70, 3);
} catch {}
try {
  await buffer54.mapAsync(GPUMapMode.WRITE);
} catch {}
let buffer56 = device0.createBuffer({size: 56, usage: GPUBufferUsage.INDIRECT});
let commandEncoder41 = device0.createCommandEncoder({});
let textureView31 = texture36.createView({format: 'r32uint'});
try {
renderBundleEncoder0.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(3, buffer45);
} catch {}
let pipeline2 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2}});
let imageData6 = new ImageData(8, 4);
let buffer57 = device0.createBuffer({size: 56, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder6.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer50, 0, 2);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(4, buffer55, 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 4, new DataView(new Uint8Array(3450).map((_, i) => i).buffer), 311, 8);
} catch {}
try {
globalThis.someLabel = commandEncoder19.label;
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: true }},
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 4, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 167,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 351,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 383,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder42 = device0.createCommandEncoder({});
let texture37 = device0.createTexture({
  size: {width: 80, height: 60, depthOrArrayLayers: 4},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture38 = device0.createTexture({
  size: {width: 120, height: 120, depthOrArrayLayers: 69},
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder16 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView25,
  depthSlice: 5,
  clearValue: { r: -652.5, g: 382.8, b: -851.6, a: -53.22, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 110, endOfPassWriteIndex: 38},
  maxDrawCount: 193648261,
});
try {
renderBundleEncoder7.setPipeline(pipeline0);
} catch {}
await gc();
let texture39 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 26},
  mipLevelCount: 2,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture40 = device0.createTexture({
  size: [80, 60, 330],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline0);
} catch {}
try {
buffer14.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let querySet2 = device0.createQuerySet({type: 'timestamp', count: 357});
let textureView32 = texture37.createView({dimension: '2d'});
try {
computePassEncoder11.setPipeline(pipeline2);
} catch {}
try {
commandEncoder32.resolveQuerySet(querySet0, 32, 0, buffer48, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let buffer58 = device0.createBuffer({size: 64, usage: GPUBufferUsage.VERTEX});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], stencilReadOnly: true});
try {
computePassEncoder6.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(211);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.setVertexBuffer(6, buffer45);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer24, 'uint32', 4, 7);
} catch {}
let arrayBuffer2 = buffer26.getMappedRange(0, 0);
let imageData7 = new ImageData(36, 36);
try {
adapter0.label = '\u2562\u00f7\u0f56\uea50\ubbea\u0a3e\u8f4d\ucbf5';
} catch {}
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true});
try {
renderBundleEncoder7.setVertexBuffer(0, buffer45, 0, 49);
} catch {}
let commandEncoder43 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(2, bindGroup0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer49, 'uint16', 42, 21);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer45, 0, 5);
} catch {}
try {
renderPassEncoder2.insertDebugMarker('\uf2b7');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder44 = device0.createCommandEncoder({});
let textureView33 = texture8.createView({});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']});
try {
computePassEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(3506), 164, 0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(3, buffer17, 0, 12);
} catch {}
try {
commandEncoder35.resolveQuerySet(querySet0, 45, 0, buffer57, 0);
} catch {}
let commandEncoder45 = device0.createCommandEncoder({});
let texture41 = device0.createTexture({
  label: '\ud9e4\u0385\u082c',
  size: {width: 160, height: 120, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true, stencilReadOnly: true});
let externalTexture3 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
computePassEncoder7.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeBuffer(buffer24, 4, new BigInt64Array(21298).map((_, i) => BigInt(i - 2)), 1822, 0);
} catch {}
let textureView34 = texture35.createView({});
let texture42 = device0.createTexture({
  size: [160],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView35 = texture2.createView({});
let externalTexture4 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder8.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(29), 2, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer14, 'uint32', 0, 15);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 4, new Float32Array(5355).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.599)), 330, 0);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline0);
} catch {}
try {
commandEncoder45.copyBufferToBuffer(buffer55, 0, buffer26, 0, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder46 = device0.createCommandEncoder({});
let texture43 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rg32uint'],
});
let textureView36 = texture11.createView({});
try {
computePassEncoder12.setBindGroup(2, bindGroup1, new Uint32Array(3657), 589, 0);
} catch {}
try {
buffer16.unmap();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder47 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(0, bindGroup1, new Uint32Array(675), 159, 0);
} catch {}
try {
computePassEncoder3.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer15, 'uint16', 12, 18);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer55, 16, 3);
} catch {}
document.body.prepend(canvas1);
let imageBitmap0 = await createImageBitmap(canvas0);
let imageData8 = new ImageData(32, 4);
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {binding: 5, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }},
    {binding: 7, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 186,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let texture44 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 21},
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView37 = texture3.createView({baseArrayLayer: 3, arrayLayerCount: 6});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']});
let sampler8 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 72.16});
try {
renderPassEncoder5.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup1, new Uint32Array(91), 35, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let imageData9 = new ImageData(4, 20);
let texture45 = device0.createTexture({
  size: [160, 120, 661],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture46 = device0.createTexture({
  size: {width: 80, height: 60, depthOrArrayLayers: 62},
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView38 = texture24.createView({});
try {
computePassEncoder10.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer58);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer57, 'uint32', 4, 7);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline0);
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
let textureView39 = texture40.createView({baseMipLevel: 2, mipLevelCount: 1});
let sampler9 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.49,
  maxAnisotropy: 11,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup0, new Uint32Array(1066), 50, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(181);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer50, 0, 0);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(3, buffer17, 12);
} catch {}
try {
commandEncoder18.clearBuffer(buffer55);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.STORAGE_BINDING, alphaMode: 'opaque'});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 7, y: 32, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture47 = device0.createTexture({
  size: {width: 60},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1});
try {
renderPassEncoder5.setIndexBuffer(buffer14, 'uint32', 4, 10);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer17, 'uint32', 48, 1);
} catch {}
let buffer59 = device0.createBuffer({
  size: 172,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture48 = device0.createTexture({
  size: [20, 15, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler10 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 12,
});
try {
renderBundleEncoder6.setPipeline(pipeline1);
} catch {}
try {
buffer49.unmap();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let autogeneratedBindGroupLayout1 = pipeline0.getBindGroupLayout(1);
let texture49 = gpuCanvasContext1.getCurrentTexture();
let externalTexture5 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder0.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(0, buffer53, 0, 6);
} catch {}
try {
buffer15.unmap();
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 3, resource: externalTexture3},
    {binding: 436, resource: externalTexture4},
    {binding: 1, resource: textureView8},
    {binding: 82, resource: {buffer: buffer52}},
    {binding: 0, resource: textureView3},
    {binding: 144, resource: {buffer: buffer53}},
    {binding: 37, resource: {buffer: buffer59}},
  ],
});
let buffer60 = device0.createBuffer({size: 48, usage: GPUBufferUsage.INDEX, mappedAtCreation: false});
let textureView40 = texture17.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 12});
let externalTexture6 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder12.setBindGroup(1, bindGroup1, new Uint32Array(18), 1, 0);
} catch {}
try {
computePassEncoder4.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer60, 'uint32', 4, 27);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup0, new Uint32Array(421), 18, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer57, 'uint16', 2, 20);
} catch {}
try {
device0.queue.writeBuffer(buffer50, 0, new DataView(new ArrayBuffer(5280)), 93, 0);
} catch {}
let commandEncoder49 = device0.createCommandEncoder({});
let texture50 = device0.createTexture({
  size: [128],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder17 = commandEncoder44.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -301.2, g: -978.6, b: 765.1, a: 267.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder9.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline0);
} catch {}
try {
commandEncoder47.copyTextureToTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture22,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [
    {binding: 37, resource: {buffer: buffer59}},
    {binding: 436, resource: externalTexture4},
    {binding: 144, resource: {buffer: buffer53}},
  ],
});
try {
computePassEncoder12.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup0, new Uint32Array(2591), 15, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer47, 'uint16', 4, 1);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(626), 16, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline0);
} catch {}
let buffer61 = device0.createBuffer({size: 164, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, mappedAtCreation: false});
let textureView41 = texture24.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder11.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer17, 56, 38);
} catch {}
try {
commandEncoder48.copyTextureToTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture44,
  mipLevel: 0,
  origin: {x: 5, y: 30, z: 4},
  aspect: 'all',
},
{width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout1]});
try {
computePassEncoder10.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 36, new Uint32Array(12004).map((_, i) => i * 3), 4540, 0);
} catch {}
let autogeneratedBindGroupLayout2 = pipeline1.getBindGroupLayout(0);
try {
renderPassEncoder11.insertDebugMarker('\u56f0');
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'gamma28curve'} });
let autogeneratedBindGroupLayout3 = pipeline2.getBindGroupLayout(0);
let commandEncoder50 = device0.createCommandEncoder({});
try {
renderBundleEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(0, buffer50, 0, 2);
} catch {}
try {
renderPassEncoder16.pushDebugGroup('\u{1fa6d}');
} catch {}
try {
device0.queue.writeBuffer(buffer15, 0, new Float32Array(8768).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.748)), 4563, 0);
} catch {}
let buffer62 = device0.createBuffer({size: 60, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder51 = device0.createCommandEncoder();
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
textureView35.label = '\ub5ef\ub7d3\ub318';
} catch {}
let commandEncoder52 = device0.createCommandEncoder({});
let texture51 = device0.createTexture({
  size: [80, 60, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder3.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer57, 'uint32', 12);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(7, buffer50, 0);
} catch {}
try {
buffer25.unmap();
} catch {}
let bindGroup4 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 144, resource: {buffer: buffer53}},
    {binding: 82, resource: {buffer: buffer62}},
    {binding: 0, resource: textureView3},
    {binding: 436, resource: externalTexture2},
    {binding: 37, resource: {buffer: buffer61}},
    {binding: 3, resource: externalTexture0},
    {binding: 1, resource: textureView4},
  ],
});
let computePassEncoder15 = commandEncoder41.beginComputePass();
try {
computePassEncoder15.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3, buffer45, 0, 2);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder16.popDebugGroup();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let imageData10 = new ImageData(20, 212);
let bindGroup5 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 64, resource: textureView17},
    {binding: 1, resource: externalTexture5},
    {binding: 4, resource: textureView14},
    {binding: 0, resource: {buffer: buffer0}},
    {binding: 630, resource: textureView16},
  ],
});
let commandEncoder53 = device0.createCommandEncoder({});
let texture52 = device0.createTexture({
  size: [160, 120, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView42 = texture47.createView({});
try {
computePassEncoder13.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(5, buffer58, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup4);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer17, 'uint16', 136, 22);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline1);
} catch {}
try {
commandEncoder24.resolveQuerySet(querySet2, 13, 0, buffer53, 0);
} catch {}
let textureView43 = texture5.createView({arrayLayerCount: 1});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder10.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(7, buffer62, 0, 22);
} catch {}
document.body.append(canvas0);
let commandEncoder54 = device0.createCommandEncoder({});
let texture53 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder10.setBindGroup(3, bindGroup0, []);
} catch {}
try {
renderPassEncoder9.beginOcclusionQuery(199);
} catch {}
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer47, 'uint16', 20, 3);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 24, new Uint32Array(23730).map((_, i) => i * 3), 1719, 0);
} catch {}
let commandEncoder55 = device0.createCommandEncoder({});
let computePassEncoder16 = commandEncoder46.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 169, endOfPassWriteIndex: 94}});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']});
try {
renderPassEncoder0.setVertexBuffer(2, buffer17, 0, 29);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture26,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(156).fill(137), /* required buffer size: 156 */
{offset: 156}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let buffer63 = device0.createBuffer({size: 224, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder56 = device0.createCommandEncoder({});
let textureView44 = texture37.createView({dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1});
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(7, buffer48, 12, 12);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let externalTexture7 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'display-p3'});
try {
computePassEncoder16.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer48, 0, 29);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(2, buffer53);
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 6, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 7},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture54 = device0.createTexture({
  size: [30, 30, 1],
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture55 = device0.createTexture({
  size: [80, 60, 330],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rg32uint'],
});
try {
device0.queue.submit([]);
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
let texture56 = device0.createTexture({
  size: {width: 40, height: 30, depthOrArrayLayers: 49},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup4, new Uint32Array(125), 8, 0);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(260);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer53, 4, 2);
} catch {}
let buffer64 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder58 = device0.createCommandEncoder({});
let textureView45 = texture2.createView({baseMipLevel: 0});
let sampler11 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMinClamp: 47.65, lodMaxClamp: 59.85});
try {
computePassEncoder11.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer48, 0);
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u6d85');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 4, y: 31, z: 0},
  aspect: 'all',
}, new Uint8Array(149).fill(197), /* required buffer size: 149 */
{offset: 149, bytesPerRow: 35}, {width: 3, height: 7, depthOrArrayLayers: 0});
} catch {}
let pipeline3 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 240, shaderLocation: 6},
          {format: 'unorm8x4', offset: 288, shaderLocation: 7},
          {format: 'sint8x2', offset: 300, shaderLocation: 10},
          {format: 'snorm16x2', offset: 2044, shaderLocation: 0},
          {format: 'uint32x2', offset: 180, shaderLocation: 1},
          {format: 'uint8x4', offset: 420, shaderLocation: 15},
          {format: 'snorm16x2', offset: 20, shaderLocation: 12},
          {format: 'float16x2', offset: 304, shaderLocation: 3},
          {format: 'sint32x4', offset: 148, shaderLocation: 9},
          {format: 'sint32', offset: 52, shaderLocation: 8},
          {format: 'snorm8x2', offset: 152, shaderLocation: 14},
          {format: 'sint16x2', offset: 632, shaderLocation: 2},
          {format: 'uint32x3', offset: 116, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 16,
        attributes: [
          {format: 'sint8x2', offset: 0, shaderLocation: 11},
          {format: 'float32x4', offset: 0, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: false},
});
try {
computePassEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup2);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer17, 'uint32', 124, 18);
} catch {}
try {
device0.queue.writeBuffer(buffer24, 0, new Float32Array(33537).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.462)), 9899, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder59 = device0.createCommandEncoder({});
try {
renderPassEncoder1.setIndexBuffer(buffer49, 'uint32', 4, 3);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer12, 'uint16', 0, 4);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(1, buffer48, 0, 0);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(74); };
} catch {}
try {
adapter0.label = '\ufa69\u{1fa79}\u{1fb67}\uc901\u0993\u0600\u36de\u{1ffad}\u{1f79f}\u365d\ue9ff';
} catch {}
let bindGroup6 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 144, resource: {buffer: buffer53, offset: 0}},
    {binding: 436, resource: externalTexture4},
    {binding: 37, resource: {buffer: buffer61}},
    {binding: 82, resource: {buffer: buffer52}},
    {binding: 0, resource: textureView0},
    {binding: 3, resource: externalTexture3},
    {binding: 1, resource: textureView1},
  ],
});
let commandEncoder60 = device0.createCommandEncoder({});
let renderPassEncoder18 = commandEncoder42.beginRenderPass({
  colorAttachments: [{view: textureView39, depthSlice: 37, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 213038659,
});
try {
computePassEncoder5.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer47, 'uint16', 14, 27);
} catch {}
let imageData11 = new ImageData(84, 8);
let textureView46 = texture40.createView({format: 'rg32uint', mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true});
try {
computePassEncoder1.setBindGroup(2, bindGroup6, new Uint32Array(1203), 142, 0);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(1, buffer53);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 8, new Uint32Array(12390).map((_, i) => i * 5), 12134, 0);
} catch {}
canvas0.width = 656;
let buffer65 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST});
let commandEncoder61 = device0.createCommandEncoder({});
let texture57 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder10.setBindGroup(0, bindGroup3, new Uint32Array(280), 16, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 8, new Float32Array(3302).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.624)), 397, 4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 436, resource: externalTexture6},
    {binding: 37, resource: {buffer: buffer61}},
    {binding: 0, resource: textureView0},
    {binding: 82, resource: {buffer: buffer49}},
    {binding: 3, resource: externalTexture6},
    {binding: 1, resource: textureView8},
    {binding: 144, resource: {buffer: buffer53}},
  ],
});
let buffer66 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder62 = device0.createCommandEncoder();
let texture58 = device0.createTexture({
  size: {width: 30, height: 30, depthOrArrayLayers: 167},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView47 = texture58.createView({format: 'rg32uint', mipLevelCount: 1, baseArrayLayer: 15, arrayLayerCount: 72});
try {
renderPassEncoder17.setIndexBuffer(buffer15, 'uint16', 8, 11);
} catch {}
await gc();
let buffer67 = device0.createBuffer({size: 208, usage: GPUBufferUsage.COPY_SRC});
let texture59 = device0.createTexture({
  size: [20, 15, 45],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder10.setBindGroup(3, bindGroup4, new Uint32Array(1345), 75, 0);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(79);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer14, 'uint16', 24, 4);
} catch {}
try {
renderBundleEncoder0.setBindGroup(3, bindGroup5, new Uint32Array(3004), 424, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer53);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
renderBundleEncoder4.pushDebugGroup('\ub8ff');
} catch {}
let commandEncoder63 = device0.createCommandEncoder();
let texture60 = gpuCanvasContext0.getCurrentTexture();
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer47, 'uint16', 28, 9);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(2, buffer58, 0, 23);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
buffer16.unmap();
} catch {}
try {
renderBundleEncoder4.popDebugGroup();
} catch {}
let imageData12 = new ImageData(104, 156);
let bindGroup8 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 37, resource: {buffer: buffer61, offset: 0}},
    {binding: 436, resource: externalTexture2},
    {binding: 82, resource: {buffer: buffer52}},
    {binding: 0, resource: textureView3},
    {binding: 1, resource: textureView4},
    {binding: 144, resource: {buffer: buffer53}},
    {binding: 3, resource: externalTexture6},
  ],
});
try {
computePassEncoder16.setBindGroup(1, bindGroup7, new Uint32Array(1780), 371, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup5);
} catch {}
try {
commandEncoder56.copyBufferToBuffer(buffer17, 60, buffer11, 0, 0);
} catch {}
try {
commandEncoder53.clearBuffer(buffer48);
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: imageData4,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 18, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData13 = new ImageData(32, 20);
try {
externalTexture6.label = '\u14b8\ubebc\u75a3\u05f3\u6934';
} catch {}
let commandEncoder64 = device0.createCommandEncoder({});
try {
renderBundleEncoder8.setPipeline(pipeline3);
} catch {}
let buffer68 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let textureView48 = texture34.createView({baseMipLevel: 0});
let computePassEncoder17 = commandEncoder18.beginComputePass();
try {
renderPassEncoder18.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer61, 'uint16', 0, 12);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(1, buffer62);
} catch {}
let commandEncoder65 = device0.createCommandEncoder({});
try {
renderBundleEncoder12.setIndexBuffer(buffer15, 'uint16', 8, 0);
} catch {}
try {
buffer47.unmap();
} catch {}
try {
commandEncoder35.copyBufferToBuffer(buffer46, 4, buffer15, 12, 8);
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 630, resource: textureView16},
    {binding: 0, resource: {buffer: buffer14}},
    {binding: 4, resource: textureView14},
    {binding: 64, resource: textureView17},
    {binding: 1, resource: externalTexture4},
  ],
});
let commandEncoder66 = device0.createCommandEncoder({});
let texture61 = device0.createTexture({
  size: [15, 15, 51],
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView49 = texture40.createView({mipLevelCount: 1});
try {
computePassEncoder13.setBindGroup(0, bindGroup4, new Uint32Array(523), 50, 0);
} catch {}
let buffer69 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let commandBuffer0 = commandEncoder52.finish();
let textureView50 = texture42.createView({});
let textureView51 = texture35.createView({});
try {
computePassEncoder10.setBindGroup(0, bindGroup6, []);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
commandEncoder31.copyTextureToTexture({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 19, y: 44, z: 0},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 1,
  origin: {x: 12, y: 0, z: 2},
  aspect: 'all',
},
{width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: canvas1,
  origin: { x: 6, y: 10 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u8715\u078d\ua14a\ua0dc\ueb06';
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 11, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 229,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let textureView52 = texture61.createView({baseMipLevel: 0, baseArrayLayer: 3, arrayLayerCount: 7});
let texture62 = device0.createTexture({
  size: [160, 120, 661],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView53 = texture1.createView({dimension: '2d-array', aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1});
try {
renderBundleEncoder11.setBindGroup(0, bindGroup0, new Uint32Array(6079), 2_130, 0);
} catch {}
try {
  await promise5;
} catch {}
let imageData14 = new ImageData(56, 4);
let texture63 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder17.setBindGroup(3, bindGroup9, new Uint32Array(627), 34, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(6, buffer45);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer12, 'uint16', 0, 5);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(0, buffer58, 0);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
let commandEncoder67 = device0.createCommandEncoder({});
let texture64 = device0.createTexture({
  size: {width: 30, height: 30, depthOrArrayLayers: 12},
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder18 = commandEncoder60.beginComputePass();
try {
device0.queue.writeBuffer(buffer65, 4, new Float32Array(2707).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.1866)), 593, 4);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup8);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer15, 'uint32', 16, 18);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 1, y: 8 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup10 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 82, resource: {buffer: buffer61}},
    {binding: 1, resource: textureView8},
    {binding: 37, resource: {buffer: buffer61}},
    {binding: 3, resource: externalTexture6},
    {binding: 0, resource: textureView3},
    {binding: 144, resource: {buffer: buffer53, size: 101}},
    {binding: 436, resource: externalTexture5},
  ],
});
let textureView54 = texture4.createView({mipLevelCount: 1});
let computePassEncoder19 = commandEncoder66.beginComputePass();
try {
renderPassEncoder18.setIndexBuffer(buffer24, 'uint32', 4, 2);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline3);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let bindGroup11 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 436, resource: externalTexture0},
    {binding: 82, resource: {buffer: buffer14}},
    {binding: 3, resource: externalTexture4},
    {binding: 37, resource: {buffer: buffer59}},
    {binding: 144, resource: {buffer: buffer53, offset: 0}},
    {binding: 0, resource: textureView3},
    {binding: 1, resource: textureView1},
  ],
});
let buffer70 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let commandEncoder68 = device0.createCommandEncoder({});
let textureView55 = texture1.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder17.setBindGroup(0, bindGroup8, []);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer12, 'uint32', 44, 6);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(6, buffer50, 0, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 4, new BigInt64Array(3103).map((_, i) => BigInt(i - 2)), 1442, 0);
} catch {}
let arrayBuffer3 = buffer48.getMappedRange(32, 4);
try {
  await promise6;
} catch {}
let commandEncoder69 = device0.createCommandEncoder({});
let texture65 = device0.createTexture({size: [80, 60, 330], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
computePassEncoder17.setBindGroup(3, bindGroup2, new Uint32Array(6970), 481, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setStencilReference(1182);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(1, buffer53);
} catch {}
try {
commandEncoder38.resolveQuerySet(querySet0, 11, 23, buffer25, 256);
} catch {}
try {
computePassEncoder0.setBindGroup(2, bindGroup3, new Uint32Array(1643), 155, 0);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup5);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup4, new Uint32Array(1387), 86, 0);
} catch {}
try {
buffer58.unmap();
} catch {}
let textureView56 = texture15.createView({dimension: '2d', format: 'rgba8uint', baseArrayLayer: 5});
let textureView57 = texture2.createView({});
try {
computePassEncoder18.setBindGroup(2, bindGroup7);
} catch {}
try {
computePassEncoder11.setBindGroup(0, bindGroup0, new Uint32Array(686), 24, 0);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer64, 0, 0);
} catch {}
try {
commandEncoder59.insertDebugMarker('\u0e6b');
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 70, resource: {buffer: buffer70, size: 260}}, {binding: 1, resource: sampler7}],
});
let buffer71 = device0.createBuffer({
  size: 40,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder70 = device0.createCommandEncoder();
try {
renderBundleEncoder9.setVertexBuffer(1, buffer62, 0, 5);
} catch {}
let arrayBuffer4 = buffer48.getMappedRange(40, 0);
try {
commandEncoder32.resolveQuerySet(querySet1, 16, 0, buffer66, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 42, y: 41 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 630, resource: textureView16},
    {binding: 1, resource: externalTexture6},
    {binding: 4, resource: textureView14},
    {binding: 64, resource: textureView15},
    {binding: 0, resource: {buffer: buffer14}},
  ],
});
try {
renderPassEncoder13.setIndexBuffer(buffer17, 'uint32', 32, 2);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder71 = device0.createCommandEncoder({});
let texture66 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView58 = texture31.createView({});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true});
try {
computePassEncoder13.setBindGroup(3, bindGroup5, new Uint32Array(19), 1, 0);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer12, 'uint16', 6, 20);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup12);
} catch {}
let buffer72 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
try {
renderPassEncoder14.setBindGroup(3, bindGroup8, new Uint32Array(169), 7, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(252);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer53, 'uint32', 0, 30);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer48, 0, 10);
} catch {}
let texture67 = device0.createTexture({
  size: [40, 30, 165],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder19 = commandEncoder68.beginRenderPass({colorAttachments: [{view: textureView49, depthSlice: 31, loadOp: 'clear', storeOp: 'discard'}]});
try {
computePassEncoder11.setBindGroup(2, bindGroup11, new Uint32Array(695), 50, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup12);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer69, 'uint32', 8, 0);
} catch {}
try {
buffer55.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer69, 24, new Uint32Array(2023).map((_, i) => i * 7), 380, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder72 = device0.createCommandEncoder({});
let textureView59 = texture37.createView({dimension: '2d'});
let texture68 = device0.createTexture({size: {width: 15}, dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC});
let externalTexture8 = device0.importExternalTexture({source: videoFrame6});
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup9);
} catch {}
try {
commandEncoder55.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 160 */
  offset: 160,
  buffer: buffer66,
}, {
  texture: texture2,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer55, 4, new Uint32Array(20582).map((_, i) => i * 4), 1779, 0);
} catch {}
let textureView60 = texture15.createView({format: 'rgba8uint', baseArrayLayer: 5, arrayLayerCount: 1});
let renderPassEncoder20 = commandEncoder65.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -488.3, g: 711.5, b: -953.9, a: 563.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderBundleEncoder0.setIndexBuffer(buffer60, 'uint16', 10, 12);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let commandEncoder73 = device0.createCommandEncoder({});
let textureView61 = texture30.createView({dimension: '3d'});
try {
device0.queue.writeBuffer(buffer65, 32, new BigInt64Array(4137).map((_, i) => BigInt(i - 2)), 1321, 0);
} catch {}
document.body.append(canvas0);
let commandEncoder74 = device0.createCommandEncoder({});
let texture69 = device0.createTexture({
  size: [80],
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture70 = gpuCanvasContext0.getCurrentTexture();
let textureView62 = texture1.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 1});
try {
renderBundleEncoder8.setBindGroup(0, bindGroup5);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer72, 'uint16', 18, 8);
} catch {}
try {
commandEncoder74.clearBuffer(buffer11);
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 144, resource: {buffer: buffer53}},
    {binding: 3, resource: externalTexture7},
    {binding: 82, resource: {buffer: buffer52, size: 16}},
    {binding: 1, resource: textureView1},
    {binding: 436, resource: externalTexture6},
    {binding: 0, resource: textureView3},
    {binding: 37, resource: {buffer: buffer68}},
  ],
});
let buffer73 = device0.createBuffer({size: 160, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(493), 26, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 16, new DataView(new Uint8Array(9032).map((_, i) => i).buffer), 2405, 16);
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [
    {binding: 144, resource: {buffer: buffer70}},
    {binding: 436, resource: externalTexture1},
    {binding: 37, resource: {buffer: buffer59}},
  ],
});
let commandEncoder75 = device0.createCommandEncoder({});
try {
computePassEncoder4.setBindGroup(2, bindGroup5, new Uint32Array(388), 13, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup7, new Uint32Array(1207), 148, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer12, 'uint16', 20, 2);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(2, buffer64, 0);
} catch {}
let textureView63 = texture5.createView({});
let pipeline4 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule3, constants: {}, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALL}]},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 176,
        attributes: [
          {format: 'sint32', offset: 48, shaderLocation: 2},
          {format: 'float16x4', offset: 24, shaderLocation: 4},
          {format: 'float32', offset: 24, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 40, shaderLocation: 0},
          {format: 'sint8x2', offset: 4, shaderLocation: 10},
          {format: 'sint32x4', offset: 0, shaderLocation: 9},
          {format: 'sint8x2', offset: 2, shaderLocation: 8},
          {format: 'snorm8x4', offset: 0, shaderLocation: 6},
          {format: 'snorm16x4', offset: 52, shaderLocation: 12},
          {format: 'snorm8x2', offset: 22, shaderLocation: 7},
          {format: 'uint16x2', offset: 44, shaderLocation: 5},
          {format: 'sint16x4', offset: 8, shaderLocation: 11},
          {format: 'float32', offset: 16, shaderLocation: 3},
          {format: 'uint32x2', offset: 44, shaderLocation: 15},
          {format: 'uint8x4', offset: 28, shaderLocation: 1},
        ],
      },
    ],
  },
});
let bindGroup16 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 144, resource: {buffer: buffer53}},
    {binding: 1, resource: textureView8},
    {binding: 82, resource: {buffer: buffer62, size: 32}},
    {binding: 0, resource: textureView0},
    {binding: 37, resource: {buffer: buffer61}},
    {binding: 436, resource: externalTexture7},
    {binding: 3, resource: externalTexture6},
  ],
});
let textureView64 = texture5.createView({dimension: '2d-array'});
let textureView65 = texture27.createView({dimension: '2d-array'});
try {
computePassEncoder10.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer57, 'uint32', 4, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup6);
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(82, 61);
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt709', transfer: 'smpteSt4281'} });
let bindGroup17 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 0, resource: textureView0},
    {binding: 144, resource: {buffer: buffer70}},
    {binding: 82, resource: {buffer: buffer61}},
    {binding: 37, resource: {buffer: buffer59}},
    {binding: 3, resource: externalTexture8},
    {binding: 1, resource: textureView8},
    {binding: 436, resource: externalTexture6},
  ],
});
let texture71 = device0.createTexture({
  size: {width: 160, height: 120, depthOrArrayLayers: 661},
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder19.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup13, new Uint32Array(2431), 9, 0);
} catch {}
let arrayBuffer5 = buffer26.getMappedRange(8, 0);
let autogeneratedBindGroupLayout4 = pipeline4.getBindGroupLayout(2);
let bindGroup18 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 436, resource: externalTexture3},
    {binding: 0, resource: textureView0},
    {binding: 144, resource: {buffer: buffer73, size: 96}},
    {binding: 3, resource: externalTexture2},
    {binding: 37, resource: {buffer: buffer68}},
    {binding: 82, resource: {buffer: buffer52}},
    {binding: 1, resource: textureView62},
  ],
});
let commandEncoder76 = device0.createCommandEncoder({});
try {
renderPassEncoder7.setBindGroup(0, bindGroup9);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer72, 'uint32', 0, 10);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer73, 28);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(75).fill(150), /* required buffer size: 75 */
{offset: 75, bytesPerRow: 30}, {width: 2, height: 7, depthOrArrayLayers: 0});
} catch {}
let buffer74 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let sampler12 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 81.11});
try {
renderPassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer55, 0, 12);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline0);
} catch {}
try {
commandEncoder58.clearBuffer(buffer70);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(23).fill(200), /* required buffer size: 23 */
{offset: 23, bytesPerRow: 97}, {width: 3, height: 4, depthOrArrayLayers: 0});
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
buffer11.unmap();
} catch {}
let promise7 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule0, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA}]},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 4, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 6},
          {format: 'snorm8x4', offset: 12, shaderLocation: 9},
          {format: 'sint32x3', offset: 0, shaderLocation: 11},
          {format: 'unorm16x4', offset: 4, shaderLocation: 12},
          {format: 'sint16x2', offset: 4, shaderLocation: 14},
          {format: 'snorm16x2', offset: 4, shaderLocation: 10},
          {format: 'sint16x4', offset: 4, shaderLocation: 0},
          {format: 'uint32', offset: 0, shaderLocation: 4},
          {format: 'uint8x4', offset: 0, shaderLocation: 5},
          {format: 'sint32', offset: 0, shaderLocation: 8},
          {format: 'snorm8x4', offset: 0, shaderLocation: 2},
          {format: 'sint32x3', offset: 0, shaderLocation: 3},
          {format: 'sint16x2', offset: 0, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front'},
});
try {
computePassEncoder16.setBindGroup(2, bindGroup0, new Uint32Array(176), 6, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup3, new Uint32Array(3373), 953, 0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer60, 'uint32', 12, 1);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(2, buffer64, 0, 2);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas0);
let bindGroup19 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 70, resource: {buffer: buffer70}}]});
let buffer75 = device0.createBuffer({
  size: 460,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder78 = device0.createCommandEncoder({});
let textureView66 = texture11.createView({dimension: '2d-array'});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder13.setBindGroup(3, bindGroup19, new Uint32Array(2843), 192, 0);
} catch {}
try {
renderPassEncoder4.setStencilReference(1898);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: imageData12,
  origin: { x: 14, y: 44 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder16.setBindGroup(0, bindGroup7, new Uint32Array(4451), 362, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(111);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer75, 'uint16', 20, 137);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
let commandEncoder79 = device0.createCommandEncoder();
let textureView67 = texture36.createView({arrayLayerCount: 1});
let texture72 = device0.createTexture({
  size: {width: 80},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
buffer62.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer50, 0, new DataView(new ArrayBuffer(135880)), 3421, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 15, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(372).fill(172), /* required buffer size: 372 */
{offset: 372, bytesPerRow: 7}, {width: 0, height: 11, depthOrArrayLayers: 0});
} catch {}
let imageData15 = new ImageData(12, 8);
let buffer76 = device0.createBuffer({size: 108, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder80 = device0.createCommandEncoder({});
try {
renderBundleEncoder2.setVertexBuffer(5, buffer58);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let arrayBuffer6 = buffer54.getMappedRange(0, 0);
let bindGroup20 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 144, resource: {buffer: buffer74}},
    {binding: 436, resource: externalTexture3},
    {binding: 1, resource: textureView62},
    {binding: 37, resource: {buffer: buffer61}},
    {binding: 3, resource: externalTexture3},
    {binding: 82, resource: {buffer: buffer49}},
    {binding: 0, resource: textureView0},
  ],
});
try {
renderPassEncoder10.setVertexBuffer(1, buffer55, 0, 21);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup14, new Uint32Array(1353), 47, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let texture73 = device0.createTexture({
  size: [80, 60, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint32', 4, 46);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer55, 4, 0);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(3, buffer45);
} catch {}
let textureView68 = texture41.createView({});
let sampler13 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 99.87});
try {
renderBundleEncoder15.setBindGroup(1, bindGroup16, []);
} catch {}
let bindGroup21 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 70, resource: {buffer: buffer70}}, {binding: 1, resource: sampler7}],
});
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]});
let texture74 = gpuCanvasContext1.getCurrentTexture();
let textureView69 = texture4.createView({baseArrayLayer: 0});
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let pipeline5 = await promise7;
try {
offscreenCanvas0.getContext('webgl');
} catch {}
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 186,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let commandEncoder81 = device0.createCommandEncoder({});
let texture75 = device0.createTexture({size: [128, 128, 34], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder9.setVertexBuffer(4, buffer50, 0, 1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 18, y: 7, z: 0},
  aspect: 'all',
}, new Uint8Array(0).fill(31), /* required buffer size: 0 */
{offset: 0, bytesPerRow: 459}, {width: 55, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture5.label;
} catch {}
let textureView70 = texture17.createView({baseArrayLayer: 6, arrayLayerCount: 2});
try {
computePassEncoder12.setBindGroup(3, bindGroup2, new Uint32Array(834), 129, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup8, new Uint32Array(3620), 352, 0);
} catch {}
try {
renderPassEncoder12.setBlendConstant({ r: -365.7, g: 296.3, b: 466.6, a: -399.0, });
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer17, 'uint16', 14, 20);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(3, buffer17);
} catch {}
try {
commandEncoder75.copyTextureToBuffer({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 24, y: 52, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 112 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 16 */
  offset: 16,
  bytesPerRow: 8448,
  buffer: buffer70,
}, {width: 28, height: 20, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(277).fill(227), /* required buffer size: 277 */
{offset: 277, bytesPerRow: 65, rowsPerImage: 20}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder15.setBindGroup(0, bindGroup0, new Uint32Array(53), 0, 0);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer62, 0);
} catch {}
let texture76 = device0.createTexture({
  size: [80, 60, 330],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder7.setBindGroup(1, bindGroup4, new Uint32Array(331), 26, 0);
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u0866');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
externalTexture1.label = '\u3b2a\u{1f630}\u{1f7c9}';
} catch {}
let buffer77 = device0.createBuffer({size: 612, usage: GPUBufferUsage.COPY_SRC});
let texture77 = device0.createTexture({
  size: [120, 120, 49],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder16.setBindGroup(1, bindGroup16);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline0);
} catch {}
await gc();
let buffer78 = device0.createBuffer({size: 131, usage: GPUBufferUsage.INDIRECT});
let commandEncoder82 = device0.createCommandEncoder({});
let textureView71 = texture23.createView({});
try {
computePassEncoder13.setBindGroup(0, bindGroup18, new Uint32Array(1023), 350, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer53, 'uint32', 0, 6);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup3, new Uint32Array(1158), 183, 0);
} catch {}
let bindGroup22 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 11, resource: {buffer: buffer68}},
    {binding: 43, resource: textureView0},
    {binding: 4, resource: {buffer: buffer75}},
    {binding: 229, resource: {buffer: buffer59}},
  ],
});
let texture78 = device0.createTexture({
  size: [128, 128, 26],
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler14 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 88.59});
try {
renderPassEncoder6.beginOcclusionQuery(56);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline4);
} catch {}
let commandEncoder83 = device0.createCommandEncoder({});
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  toneMapping: {mode: 'standard'},
});
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(89, 21);
let textureView72 = texture38.createView({baseArrayLayer: 2, arrayLayerCount: 4});
try {
renderPassEncoder13.setIndexBuffer(buffer17, 'uint16', 22, 20);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 4, new DataView(new Uint8Array(25744).map((_, i) => i).buffer), 7203, 4);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(7, buffer17);
} catch {}
let texture79 = device0.createTexture({
  size: [20, 15, 82],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView73 = texture20.createView({});
try {
renderBundleEncoder0.setPipeline(pipeline0);
} catch {}
let textureView74 = texture21.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder8.setIndexBuffer(buffer61, 'uint32', 12, 53);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline1);
} catch {}
try {
commandEncoder51.copyBufferToBuffer(buffer55, 0, buffer70, 104, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 4, new Float32Array(44936).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.5672)), 624, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder7.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup2, new Uint32Array(6054), 333, 0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(2, buffer50);
} catch {}
try {
commandEncoder72.copyTextureToTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 8, y: 17, z: 0},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 18, y: 5, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer79 = device0.createBuffer({size: 220, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder84 = device0.createCommandEncoder({});
try {
renderBundleEncoder4.setVertexBuffer(0, buffer73, 32, 88);
} catch {}
try {
buffer78.unmap();
} catch {}
try {
commandEncoder69.copyBufferToBuffer(buffer55, 0, buffer24, 0, 0);
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires readonly_and_readwrite_storage_textures;

enable f16;

alias vec3b = vec3<bool>;

@group(0) @binding(1) var sam6: sampler_comparison;

struct VertexInput16 {
  @location(9) location_9: vec2i,
  @location(10) @interpolate(flat) location_10: u32,
  @builtin(instance_index) instance_index: u32,
  @location(14) location_14: vec4f,
}

@group(0) @binding(0) var<storage, read_write> buffer80: array<array<VertexInput16, 10>>;

struct ComputeInput7 {
  @builtin(num_workgroups) num_workgroups: vec3u,
}

struct VertexInput17 {
  @location(11) location_11: vec2i,
}

@group(3) @binding(70) var<uniform> buffer87: array<array<array<array<array<vec4i, 4>, 1>, 1>, 1>, 4>;

override override6 = 0.2237;

override override7: f32;

@id(6487) override override8: u32;

fn unconst_f32(v: f32) -> f32 { return v; }

fn unconst_u32(v: u32) -> u32 { return v; }

/* zero global variables used */
@must_use 
fn fn0(a0: sampler_comparison) -> array<array<array<array<array<array<array<array<array<array<array<i32, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 45> {
  var out: array<array<array<array<array<array<array<array<array<array<array<i32, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 45>;
  let ptr55: ptr<function, array<i32, 1>> = &out[44][bitcast<u32>(out[unconst_u32(541684918)][0][0][0][bitcast<u32>(out[44][0][0][0][u32(out[unconst_u32(1116705545)][0][unconst_u32(388910004)][0][0][0][0][unconst_u32(1174148705)][0][0][0])][unconst_u32(1361377711)][0][0][unconst_u32(381614433)][0][0])][unconst_u32(373779242)][unconst_u32(811648541)][0][0][0][0])][0][0][0][0][0][0][unconst_u32(672577939)][unconst_u32(421724184)];
  vp3 = vec2i(out[unconst_u32(868255613)][unconst_u32(1220138821)][0][0][unconst_u32(543096073)][unconst_u32(275631012)][unconst_u32(1630305112)][unconst_u32(34768045)][unconst_u32(640603760)][0][unconst_u32(396506750)]);
  let ptr56: ptr<function, i32> = &out[44][unconst_u32(3842071793)][0][unconst_u32(723951295)][unconst_u32(806492689)][0][0][unconst_u32(1129753636)][0][unconst_u32(1067230250)][unconst_u32(210042265)];
  let ptr57: ptr<function, i32> = &out[unconst_u32(55814843)][0][unconst_u32(998280789)][0][0][unconst_u32(1367735665)][0][unconst_u32(191867510)][0][0][unconst_u32(1010892436)];
  let ptr58: ptr<function, i32> = &out[unconst_u32(1179517161)][0][unconst_u32(1401323334)][unconst_u32(810407503)][unconst_u32(597975758)][0][unconst_u32(347884654)][0][unconst_u32(775546188)][0][0];
  for (var jj46=0u; jj46<47; jj46++) { for (var jj74=0u; jj74<3; jj74++) { out[jj46][unconst_u32(443049541)][unconst_u32(896500516)][unconst_u32(138577103)][unconst_u32(415174592)][unconst_u32(683700102)][unconst_u32(1404431679)][0][unconst_u32(156940195)][unconst_u32(515814020)][jj74] -= out[44][0][unconst_u32(73901051)][0][0][bitcast<u32>(out[44][0][unconst_u32(526760930)][0][0][unconst_u32(240539589)][0][0][0][0][0])][0][0][0][0][unconst_u32(1085062250)]; } }
  vp3 = vec2i(out[44][0][0][unconst_u32(449954849)][0][0][0][unconst_u32(1529352405)][0][0][unconst_u32(164057968)]);
  let ptr59: ptr<function, array<array<i32, 1>, 1>> = &out[44][0][unconst_u32(862554339)][0][0][0][0][bitcast<u32>(out[unconst_u32(961144163)][0][unconst_u32(374236127)][0][0][unconst_u32(945315410)][unconst_u32(12259572)][unconst_u32(353759247)][unconst_u32(652529535)][0][bitcast<u32>(out[unconst_u32(425440544)][0][0][unconst_u32(1210439525)][0][unconst_u32(3073765273)][0][0][0][0][0])])][bitcast<u32>(out[unconst_u32(75117406)][0][unconst_u32(351991787)][unconst_u32(149716947)][unconst_u32(211865211)][0][0][0][unconst_u32(2780774271)][0][0])];
  let ptr60: ptr<function, i32> = &out[unconst_u32(112164991)][unconst_u32(1357538377)][0][0][unconst_u32(427477653)][0][0][bitcast<u32>(out[unconst_u32(346790161)][0][unconst_u32(12608170)][u32(out[unconst_u32(112310767)][unconst_u32(473426544)][0][unconst_u32(193067183)][0][0][0][unconst_u32(417980985)][unconst_u32(1776718749)][0][0])][u32(out[unconst_u32(470958004)][0][unconst_u32(1269715392)][0][0][0][0][0][unconst_u32(137839665)][0][unconst_u32(202769858)])][0][unconst_u32(508241662)][unconst_u32(530645580)][0][unconst_u32(1550157044)][0])][unconst_u32(49131656)][0][0];
  return out;
}

var<private> vp4 = array(modf(vec4h(-15756.5, 185.3, 873.2, -22896.8)), modf(vec4h(3895.8, -11610.3, 24194.7, 3039.0)), modf(vec4h(9635.5, 11587.0, 19872.1, 4220.8)), modf(vec4h(5104.4, 3661.5, 17252.2, 6707.3)), modf(vec4h(733.6, 9481.9, 9339.6, 10056.5)), modf(vec4h(9058.9, 5824.3, 6804.0, 675.9)), modf(vec4h(35750.8, 20997.6, 2262.4, 6878.3)), modf(vec4h(1282.1, 698.5, 3249.9, 14557.3)), modf(vec4h(21376.8, -11656.8, 13968.1, 9905.3)), modf(vec4h(8302.0, 13858.8, 6945.5, 37357.1)), modf(vec4h(4579.5, 12380.3, 2642.3, 7329.3)), modf(vec4h(14878.7, -1415.5, 5119.8, 841.6)), modf(vec4h(969.9, -2359.9, 4285.4, 2363.1)), modf(vec4h(14590.1, 3378.8, 14374.1, 5404.0)), modf(vec4h(3072.7, 31442.1, 28877.4, 35849.6)));

struct FragmentOutput4 {
  @location(0) @interpolate(flat) location_0: vec4u,
}

@group(1) @binding(0) var<storage, read_write> buffer82: array<array<array<array<array<array<array<array<f16, 7>, 1>, 1>, 1>, 2>, 16>, 8>>;

struct VertexInput15 {
  @location(7) @interpolate(perspective) location_7: f32,
}

@group(2) @binding(115) var st2: texture_storage_2d<r32float, read_write>;

@id(52277) override override9: f16;

var<workgroup> vw7: array<atomic<u32>, 1>;

@group(3) @binding(0) var<storage, read_write> buffer86: array<array<FragmentInput6, 40>>;

struct FragmentInput7 {
  @builtin(position) position: vec4f,
}

struct FragmentInput6 {
  @location(13) location_13: vec2u,
}

struct VertexOutput3 {
  @location(1) location_1: f32,
  @location(4) location_4: vec4f,
  @location(0) location_0: vec4u,
  @location(10) location_10: vec4h,
  @location(9) location_9: f16,
  @location(2) @interpolate(linear, either) location_2: f32,
  @location(15) @interpolate(perspective, first) location_15: vec2h,
  @builtin(position) position: vec4f,
  @location(11) @interpolate(flat, first) location_11: vec4h,
  @location(14) @interpolate(flat, centroid) location_14: i32,
  @location(3) location_3: vec2i,
  @location(7) location_7: vec2f,
  @location(5) location_5: vec2f,
  @location(6) location_6: vec2f,
}

struct ComputeInput5 {
  @builtin(workgroup_id) workgroup_id: vec3u,
}

@group(1) @binding(115) var st1: texture_storage_2d<r32float, read_write>;

fn unconst_i32(v: i32) -> i32 { return v; }

@group(3) @binding(1) var sam7: sampler_comparison;

fn unconst_bool(v: bool) -> bool { return v; }

var<private> vp3: vec2i = vec2i(476470049, 88725049);

@group(2) @binding(10) var<storage, read_write> buffer85: vec4h;

struct ComputeInput6 {
  @builtin(local_invocation_index) local_invocation_index: u32,
}

fn unconst_f16(v: f16) -> f16 { return v; }

@group(2) @binding(0) var<storage, read_write> buffer84: array<array<array<f32, 56>, 16>>;

struct FragmentInput5 {
  @location(8) location_8: vec4h,
}

struct T0 {
  f0: array<array<atomic<u32>, 2>>,
}

/* used global variables: sam6, sam7 */
@vertex
fn vertex3(@location(1) @interpolate(perspective, either) location_1: f32, a1: VertexInput15, a2: VertexInput16, @location(12) location_12: f32, a4: VertexInput17, @location(8) location_8: f32, @location(4) @interpolate(flat) location_4: u32, @location(15) location_15: u32, @location(5) @interpolate(flat, either) location_5: vec2u) -> VertexOutput3 {
  var out: VertexOutput3;
  _ = fn0(sam6);
  out.position = vec4f(f32(out.location_9));
  out.position -= vec4f(bitcast<f32>(a2.instance_index));
  out.position = vec4f(vp4[unconst_u32(1392986337)].fract.wzxw.brag);
  _ = fn0(sam6);
  var vf58: f32 = location_8;
  var vf59 = fn0(sam7);
  var vf60 = fn0(sam7);
  let ptr61: ptr<function, array<array<i32, 1>, 1>> = &vf60[44][0][unconst_u32(473035466)][unconst_u32(644333768)][unconst_u32(681277804)][0][unconst_u32(55112381)][bitcast<u32>(vf59[44][0][0][0][bitcast<u32>(vf60[unconst_u32(24952847)][0][unconst_u32(346677716)][unconst_u32(717980754)][0][unconst_u32(618698950)][0][unconst_u32(228883160)][0][0][0])][0][unconst_u32(62742736)][0][unconst_u32(240440457)][0][0])][0];
  out.location_6 -= vec2f(bitcast<f32>(vf60[unconst_u32(87398397)][unconst_u32(126191222)][unconst_u32(135775691)][0][unconst_u32(316034854)][0][0][unconst_u32(1301287074)][unconst_u32(493870365)][unconst_u32(3932274131)][0]));
  return out;
  _ = sam7;
  _ = sam6;
}

/* used global variables: buffer82, buffer84, buffer87, st1, st2 */
@fragment
fn fragment4(a0: FragmentInput5, @location(6) location_6: vec2h, a2: FragmentInput6, a3: FragmentInput7) -> @location(200) vec2u {
  var out: vec2u;
  vp4[unconst_u32(583360954)] = modf(vec4h(buffer82[arrayLength(&buffer82)][7][unconst_u32(2016027560)][unconst_u32(1211671537)][unconst_u32(349644494)][unconst_u32(75316007)][unconst_u32(348256957)][6]));
  textureStore(st2, vec2i(unconst_i32(756619699), unconst_i32(-245930981)), vec4f(vec4f(unconst_f32(0.03875e20), unconst_f32(0.1109), unconst_f32(0.1543), unconst_f32(0.5266))));
  textureStore(st1, vec2i(unconst_i32(630264849), unconst_i32(-337048747)), vec4f(vec4f(unconst_f32(0.1466), unconst_f32(0.6519), unconst_f32(0.08014), unconst_f32(0.1471))));
  textureStore(st2, vec2i(unconst_i32(641589395), unconst_i32(498720836)), vec4f(vec4f(unconst_f32(0.02645e3), unconst_f32(0.00494), unconst_f32(0.1083), unconst_f32(0.3790e-34))));
  let ptr62: ptr<storage, f16, read_write> = &buffer82[unconst_u32(1340899488)][unconst_u32(464413715)][15][1][unconst_u32(3839786015)][unconst_u32(129087616)][unconst_u32(499604685)][6];
  buffer84[unconst_u32(777256534)][unconst_u32(471107085)][unconst_u32(550996947)] = f32((*&buffer82)[arrayLength(&(*&buffer82))][7][15][unconst_u32(2195230691)][unconst_u32(301642691)][0][unconst_u32(180599116)][6]);
  vp4[unconst_u32(888648689)].fract = vec4h(buffer82[unconst_u32(1010159498)][7][unconst_u32(93686754)][1][0][unconst_u32(143966828)][0][unconst_u32(390382326)]);
  for (var jj31=0u; jj31<17; jj31++) { vp4[jj31].fract -= vec4h((*&buffer87)[unconst_u32(8480968)][0][0][unconst_u32(134068406)][3].agra); }
  let ptr63: ptr<storage, f16, read_write> = &(*&buffer82)[unconst_u32(510091074)][7][unconst_u32(929766856)][1][0][unconst_u32(84618595)][unconst_u32(995205624)][unconst_u32(1346407779)];
  return out;
  _ = buffer84;
  _ = buffer82;
  _ = st2;
  _ = buffer87;
  _ = st1;
}

/* used global variables: st1 */
@fragment
fn fragment5(@location(8) location_8: vec4h) -> FragmentOutput4 {
  var out: FragmentOutput4;
  textureStore(st1, vec2i(unconst_i32(-1475077788), unconst_i32(1207828414)), vec4f(vec4f(unconst_f32(0.3207), unconst_f32(0.09433), unconst_f32(0.01632e-38), unconst_f32(0.09034))));
  return out;
  _ = st1;
}

/* used global variables: buffer80, buffer82, buffer84, buffer85, buffer86 */
@compute @workgroup_size(2, 1, 2)
fn compute4(a0: ComputeInput5, a1: ComputeInput6, a2: ComputeInput7, @builtin(local_invocation_id) local_invocation_id: vec3u) {
  let ptr64: ptr<storage, f16, read_write> = &buffer82[unconst_u32(215395417)][unconst_u32(783895882)][15][unconst_u32(3605420)][unconst_u32(2407348738)][unconst_u32(381368759)][unconst_u32(118173653)][unconst_u32(46217733)];
  buffer80[unconst_u32(316293348)][unconst_u32(898509075)].location_10 = u32((*&buffer82)[arrayLength(&(*&buffer82))][unconst_u32(732073061)][unconst_u32(2111202538)][unconst_u32(984071908)][0][0][0][6]);
  buffer80[unconst_u32(190602286)][unconst_u32(1733135935)] = VertexInput16(vec2i(i32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6])), u32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6]), u32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6]), vec4f(f32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6])));
  let ptr65: ptr<storage, array<array<array<array<f16, 7>, 1>, 1>, 1>, read_write> = &buffer82[arrayLength(&buffer82)][unconst_u32(1198300002)][u32(buffer82[unconst_u32(96899402)][unconst_u32(621829244)][15][unconst_u32(1134023491)][unconst_u32(1679787384)][0][unconst_u32(578914107)][unconst_u32(361638586)])][unconst_u32(183935487)];
  buffer85 -= vec4h(buffer82[unconst_u32(503343278)][u32((*ptr65)[unconst_u32(115807681)][unconst_u32(629816108)][unconst_u32(87015105)][unconst_u32(1031263185)])][unconst_u32(2611630161)][1][0][u32(buffer82[u32(buffer82[unconst_u32(253226650)][7][15][1][0][0][unconst_u32(684670342)][6])][7][15][1][0][0][0][6])][0][6]);
  let ptr66: ptr<storage, array<f16, 7>, read_write> = &buffer82[unconst_u32(434656994)][7][15][unconst_u32(1243041098)][unconst_u32(468351122)][unconst_u32(289613960)][0];
  let ptr67: ptr<storage, array<array<array<array<array<f16, 7>, 1>, 1>, 1>, 2>, read_write> = &(*&buffer82)[arrayLength(&(*&buffer82))][7][unconst_u32(708933806)];
  buffer84[unconst_u32(737821132)][15][unconst_u32(810257902)] = f32(buffer82[arrayLength(&buffer82)][7][unconst_u32(366394740)][unconst_u32(1373327066)][0][0][0][6]);
  vp4[unconst_u32(363480935)] = modf(vec4h((*&buffer82)[arrayLength(&(*&buffer82))][unconst_u32(529093787)][unconst_u32(514804187)][1][0][0][0][unconst_u32(146819301)]));
  vp3 = vec2i(i32(buffer82[unconst_u32(2211035613)][7][15][1][unconst_u32(1212917309)][0][0][6]));
  let ptr68: ptr<storage, f16, read_write> = &buffer82[arrayLength(&buffer82)][7][unconst_u32(642866192)][1][unconst_u32(226050851)][0][0][unconst_u32(34741308)];
  let ptr69: ptr<storage, f32, read_write> = &(*&buffer84)[arrayLength(&(*&buffer84))][15][unconst_u32(1286148924)];
  _ = buffer84;
  _ = buffer82;
  _ = buffer86;
  _ = buffer80;
  _ = buffer85;
}`,
});
let bindGroup23 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 1, resource: sampler2}, {binding: 70, resource: {buffer: buffer70, size: 260}}],
});
let buffer88 = device0.createBuffer({size: 184, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let sampler15 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 90.17,
  maxAnisotropy: 1,
});
try {
buffer14.unmap();
} catch {}
let commandEncoder85 = device0.createCommandEncoder({});
let texture80 = device0.createTexture({
  size: {width: 120, height: 120, depthOrArrayLayers: 138},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView75 = texture11.createView({baseArrayLayer: 0});
try {
renderPassEncoder6.setVertexBuffer(1, buffer63, 0, 84);
} catch {}
try {
commandEncoder72.copyBufferToBuffer(buffer75, 28, buffer59, 8, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer69, 56, new Float32Array(15998).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.399)), 51, 0);
} catch {}
let commandEncoder86 = device0.createCommandEncoder({});
let textureView76 = texture45.createView({});
try {
computePassEncoder7.setBindGroup(1, bindGroup0, new Uint32Array(2655), 157, 0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(3, bindGroup2, new Uint32Array(410), 188, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder87 = device0.createCommandEncoder({});
let textureView77 = texture61.createView({baseMipLevel: 0, baseArrayLayer: 11, arrayLayerCount: 8});
let texture81 = device0.createTexture({
  size: [60, 60, 24],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32uint'],
});
let textureView78 = texture38.createView({dimension: 'cube-array', baseArrayLayer: 13, arrayLayerCount: 12});
let computePassEncoder20 = commandEncoder62.beginComputePass();
try {
computePassEncoder20.setPipeline(pipeline2);
} catch {}
let arrayBuffer7 = buffer48.getMappedRange(48, 0);
try {
device0.queue.writeBuffer(buffer15, 0, new Float16Array(10593).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.078)), 1376, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(60).fill(108), /* required buffer size: 60 */
{offset: 60, bytesPerRow: 34}, {width: 1, height: 8, depthOrArrayLayers: 0});
} catch {}
let textureView79 = texture15.createView({dimension: '2d', format: 'rgba8uint', mipLevelCount: 1, baseArrayLayer: 7});
let textureView80 = texture16.createView({mipLevelCount: 1});
try {
renderPassEncoder15.setIndexBuffer(buffer15, 'uint32', 40, 1);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer60, 'uint16', 4, 25);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu');
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(53); };
} catch {}
let imageData16 = new ImageData(16, 4);
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 186,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let bindGroup24 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [
    {binding: 436, resource: externalTexture7},
    {binding: 144, resource: {buffer: buffer73, offset: 0}},
    {binding: 37, resource: {buffer: buffer75}},
  ],
});
let texture82 = device0.createTexture({
  size: [60],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView81 = texture63.createView({});
try {
renderPassEncoder19.setVertexBuffer(0, buffer45, 4, 15);
} catch {}
try {
buffer56.unmap();
} catch {}
let bindGroup25 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 70, resource: {buffer: buffer70}}, {binding: 1, resource: sampler2}],
});
let texture83 = device0.createTexture({
  size: [120, 120, 49],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder21 = commandEncoder55.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
renderPassEncoder19.setBindGroup(3, bindGroup14);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup19);
} catch {}
let pipeline6 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule0, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.RED}]},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 80,
        attributes: [
          {format: 'sint32x2', offset: 0, shaderLocation: 9},
          {format: 'float16x4', offset: 52, shaderLocation: 8},
          {format: 'uint32', offset: 4, shaderLocation: 15},
          {format: 'float32', offset: 8, shaderLocation: 7},
          {format: 'sint8x2', offset: 26, shaderLocation: 11},
          {format: 'uint32x4', offset: 4, shaderLocation: 4},
          {format: 'float32x4', offset: 20, shaderLocation: 1},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12},
          {format: 'uint32x2', offset: 12, shaderLocation: 5},
          {format: 'uint32', offset: 4, shaderLocation: 10},
          {format: 'float32x4', offset: 4, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front'},
});
let commandEncoder88 = device0.createCommandEncoder({});
let texture84 = device0.createTexture({
  size: {width: 30, height: 30, depthOrArrayLayers: 12},
  sampleCount: 1,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup6);
} catch {}
await gc();
let bindGroup26 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [
    {binding: 144, resource: {buffer: buffer53}},
    {binding: 37, resource: {buffer: buffer68}},
    {binding: 436, resource: externalTexture2},
  ],
});
let textureView82 = texture82.createView({});
try {
renderPassEncoder3.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer75, 'uint32', 20, 226);
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let commandEncoder89 = device0.createCommandEncoder({});
let texture85 = device0.createTexture({
  size: [20, 15, 82],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture86 = device0.createTexture({
  size: [120],
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
  await promise8;
} catch {}
let commandEncoder90 = device0.createCommandEncoder();
let texture87 = device0.createTexture({
  size: [30, 30, 12],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setBindGroup(2, bindGroup26);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline5);
} catch {}
try {
externalTexture6.label = '\u0181\u{1fd3d}\udf0e';
} catch {}
let buffer89 = device0.createBuffer({size: 452, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder91 = device0.createCommandEncoder({});
let textureView83 = texture83.createView({dimension: '3d'});
let textureView84 = texture35.createView({mipLevelCount: 1});
try {
computePassEncoder6.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer72, 'uint32', 12, 13);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, buffer58, 0, 9);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer12, 'uint16', 0, 3);
} catch {}
let commandEncoder92 = device0.createCommandEncoder({});
let texture88 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 82},
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder16.setBindGroup(3, bindGroup23, new Uint32Array(1850), 539, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder49.copyBufferToBuffer(buffer54, 184, buffer64, 0, 0);
} catch {}
try {
commandEncoder79.copyBufferToTexture({
  /* bytesInLastRow: 176 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 576 */
  offset: 576,
  rowsPerImage: 320,
  buffer: buffer77,
}, {
  texture: texture86,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder75.copyTextureToTexture({
  texture: texture58,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 32},
  aspect: 'all',
},
{
  texture: texture71,
  mipLevel: 0,
  origin: {x: 24, y: 1, z: 26},
  aspect: 'all',
},
{width: 2, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer65, 8, new DataView(new Uint8Array(1897).map((_, i) => i).buffer), 178, 8);
} catch {}
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpte240m', transfer: 'bt2020_12bit'} });
let texture89 = device0.createTexture({
  size: [60, 60, 24],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder11.setBindGroup(0, bindGroup6, new Uint32Array(830), 310, 0);
} catch {}
try {
renderPassEncoder9.beginOcclusionQuery(27);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer73, 0, 27);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup13);
} catch {}
let textureView85 = texture88.createView({});
let texture90 = gpuCanvasContext0.getCurrentTexture();
try {
renderPassEncoder17.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup9, []);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup2, new Uint32Array(5226), 1_752, 0);
} catch {}
try {
buffer76.unmap();
} catch {}
try {
commandEncoder80.resolveQuerySet(querySet1, 23, 0, buffer74, 0);
} catch {}
let autogeneratedBindGroupLayout5 = pipeline3.getBindGroupLayout(2);
let texture91 = gpuCanvasContext0.getCurrentTexture();
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup17);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline6);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer59, 64, new Uint32Array(2072).map((_, i) => i * 7), 484, 12);
} catch {}
try {
externalTexture0.label = '\u0640\u3816\u56de\u084b';
} catch {}
try {
computePassEncoder18.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup15, new Uint32Array(1943), 148, 0);
} catch {}
let commandEncoder93 = device0.createCommandEncoder({});
let texture92 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 6},
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
renderPassEncoder16.setIndexBuffer(buffer60, 'uint16', 36, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline6);
} catch {}
let texture93 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 82},
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView86 = texture68.createView({});
let computePassEncoder22 = commandEncoder72.beginComputePass();
try {
renderPassEncoder11.setBindGroup(1, bindGroup5);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let buffer90 = device0.createBuffer({size: 196, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
computePassEncoder2.setBindGroup(0, bindGroup13);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline2);
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: canvas0,
  origin: { x: 180, y: 32 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 55, y: 16, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 10, height: 5, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let commandEncoder94 = device0.createCommandEncoder({});
try {
renderPassEncoder16.setBindGroup(1, bindGroup24, new Uint32Array(33), 5, 0);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(1, buffer73, 0, 22);
} catch {}
try {
buffer65.unmap();
} catch {}
let texture94 = device0.createTexture({size: [128, 128, 126], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder13.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup11);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup19, new Uint32Array(865), 30, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline5);
} catch {}
let texture95 = device0.createTexture({
  size: [120],
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderBundleEncoder16.setIndexBuffer(buffer57, 'uint16', 56);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder48.copyTextureToTexture({
  texture: texture76,
  mipLevel: 0,
  origin: {x: 1, y: 5, z: 17},
  aspect: 'all',
},
{
  texture: texture78,
  mipLevel: 0,
  origin: {x: 15, y: 8, z: 0},
  aspect: 'all',
},
{width: 16, height: 11, depthOrArrayLayers: 0});
} catch {}
try {
  await promise9;
} catch {}
let texture96 = device0.createTexture({
  size: {width: 60, height: 60, depthOrArrayLayers: 30},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder11.setIndexBuffer(buffer61, 'uint16', 32, 8);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer48, 0, 14);
} catch {}
try {
buffer49.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline7 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 52,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 14},
          {format: 'snorm8x4', offset: 20, shaderLocation: 5},
          {format: 'unorm16x4', offset: 0, shaderLocation: 12},
          {format: 'snorm16x2', offset: 0, shaderLocation: 3},
          {format: 'uint8x2', offset: 0, shaderLocation: 8},
          {format: 'unorm16x4', offset: 0, shaderLocation: 2},
          {format: 'uint8x4', offset: 8, shaderLocation: 7},
          {format: 'sint8x4', offset: 48, shaderLocation: 6},
          {format: 'uint8x2', offset: 18, shaderLocation: 13},
          {format: 'snorm8x4', offset: 8, shaderLocation: 0},
          {format: 'snorm8x4', offset: 0, shaderLocation: 15},
          {format: 'float16x4', offset: 0, shaderLocation: 4},
          {format: 'sint16x2', offset: 0, shaderLocation: 1},
          {format: 'sint8x2', offset: 2, shaderLocation: 9},
          {format: 'uint32x2', offset: 0, shaderLocation: 11},
        ],
      },
      {arrayStride: 72, attributes: [{format: 'uint32', offset: 12, shaderLocation: 10}]},
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
try {
externalTexture2.label = '\uffc5\u2836\u6e5e\u69a3\u7294\u{1ff28}\u07f2\udbf9\u5f06';
} catch {}
let bindGroup27 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 4, resource: {buffer: buffer68}},
    {binding: 11, resource: {buffer: buffer49}},
    {binding: 229, resource: {buffer: buffer61}},
    {binding: 43, resource: textureView3},
  ],
});
let buffer91 = device0.createBuffer({size: 315, usage: GPUBufferUsage.INDIRECT});
let textureView87 = texture83.createView({});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']});
try {
renderBundleEncoder18.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(4, buffer79, 0, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData15,
  origin: { x: 5, y: 1 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let commandEncoder95 = device0.createCommandEncoder({});
let textureView88 = texture93.createView({});
try {
renderPassEncoder7.setPipeline(pipeline4);
} catch {}
try {
commandEncoder38.copyBufferToBuffer(buffer62, 0, buffer64, 4, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer70, 48, new Uint32Array(21390).map((_, i) => i * 2), 5993, 28);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 85},
  aspect: 'all',
}, new Uint8Array(4_152_415).fill(3), /* required buffer size: 4_152_415 */
{offset: 449, bytesPerRow: 119, rowsPerImage: 141}, {width: 7, height: 64, depthOrArrayLayers: 248});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: imageData1,
  origin: { x: 4, y: 30 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 7, y: 13, z: 10},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 41, depthOrArrayLayers: 0});
} catch {}
let pipeline8 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(15); };
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer92 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder96 = device0.createCommandEncoder({});
try {
computePassEncoder15.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer63, 0, 3);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let bindGroup28 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 70, resource: {buffer: buffer70}}]});
let externalTexture9 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder9.setBindGroup(2, bindGroup28);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup13);
} catch {}
let buffer93 = device0.createBuffer({size: 536, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
commandEncoder63.copyTextureToTexture({
  texture: texture28,
  mipLevel: 3,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture67,
  mipLevel: 1,
  origin: {x: 0, y: 6, z: 24},
  aspect: 'all',
},
{width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder97 = device0.createCommandEncoder();
let texture97 = device0.createTexture({
  size: {width: 120},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: false});
try {
computePassEncoder15.setBindGroup(2, bindGroup5, new Uint32Array(1286), 106, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer47, 'uint16', 0, 0);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(1, buffer79, 0, 1);
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup20, new Uint32Array(3482), 115, 0);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(2, buffer75);
} catch {}
try {
buffer88.unmap();
} catch {}
let imageData17 = new ImageData(24, 4);
let textureView89 = texture65.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder20.setBindGroup(2, bindGroup7, new Uint32Array(526), 28, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer15, 'uint32', 8, 8);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer55, 0, 17);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup7);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: canvas1,
  origin: { x: 73, y: 14 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let buffer94 = device0.createBuffer({size: 3064, usage: GPUBufferUsage.COPY_DST});
let commandEncoder98 = device0.createCommandEncoder({});
try {
computePassEncoder10.setBindGroup(1, bindGroup8);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(4, buffer50, 0);
} catch {}
let imageData18 = new ImageData(72, 32);
let commandEncoder99 = device0.createCommandEncoder({});
try {
renderBundleEncoder20.setBindGroup(0, bindGroup15, new Uint32Array(1037), 161, 0);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(543).fill(76), /* required buffer size: 543 */
{offset: 543, bytesPerRow: 348, rowsPerImage: 30}, {width: 28, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup29 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 1, resource: sampler2}, {binding: 70, resource: {buffer: buffer70}}],
});
let texture98 = device0.createTexture({
  size: [128, 128, 26],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder1.setBindGroup(2, bindGroup4);
} catch {}
try {
buffer78.unmap();
} catch {}
try {
commandEncoder88.pushDebugGroup('\u4fff');
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new Uint32Array(14333).map((_, i) => i * 9), 1995, 0);
} catch {}
let commandEncoder100 = device0.createCommandEncoder();
let texture99 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 26},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder20.setIndexBuffer(buffer89, 'uint16', 52, 86);
} catch {}
let commandEncoder101 = device0.createCommandEncoder({});
try {
renderPassEncoder8.insertDebugMarker('\u3e81');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let commandEncoder102 = device0.createCommandEncoder();
let texture100 = device0.createTexture({
  size: {width: 120, height: 120, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder21 = commandEncoder70.beginRenderPass({
  colorAttachments: [{
  view: textureView68,
  clearValue: { r: -195.4, g: -543.6, b: -228.5, a: -450.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder4.setBindGroup(1, bindGroup11, new Uint32Array(264), 35, 0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup22, new Uint32Array(124), 1, 1);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(2, buffer50, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 0, new BigInt64Array(34443).map((_, i) => BigInt(i - 8)), 14180, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData15,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise10;
} catch {}
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let commandEncoder103 = device0.createCommandEncoder({});
let texture101 = device0.createTexture({
  size: {width: 160},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder20.setBindGroup(3, bindGroup5);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline6);
} catch {}
try {
buffer46.unmap();
} catch {}
let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, constants: {}}});
let sampler16 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 92.79,
  compare: 'greater',
  maxAnisotropy: 1,
});
try {
renderBundleEncoder2.setBindGroup(2, bindGroup2, []);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer47, 'uint16', 20, 23);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup29);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
commandEncoder69.clearBuffer(buffer55, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture88,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 1},
  aspect: 'all',
}, new Uint8Array(10_570).fill(102), /* required buffer size: 10_570 */
{offset: 13, bytesPerRow: 207, rowsPerImage: 3}, {width: 11, height: 0, depthOrArrayLayers: 18});
} catch {}
let commandEncoder104 = device0.createCommandEncoder();
let texture102 = device0.createTexture({
  size: [15, 15, 38],
  mipLevelCount: 2,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView90 = texture47.createView({aspect: 'all'});
let computePassEncoder23 = commandEncoder87.beginComputePass();
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageBitmap1 = await createImageBitmap(videoFrame0);
try {
computePassEncoder18.setBindGroup(2, bindGroup11);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(3, buffer45);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup4, new Uint32Array(760), 72, 0);
} catch {}
try {
buffer46.unmap();
} catch {}
try {
globalThis.someLabel = externalTexture9.label;
} catch {}
let bindGroup30 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 3, resource: externalTexture5},
    {binding: 436, resource: externalTexture1},
    {binding: 1, resource: textureView4},
    {binding: 82, resource: {buffer: buffer49}},
    {binding: 37, resource: {buffer: buffer88}},
    {binding: 144, resource: {buffer: buffer73, offset: 0}},
    {binding: 0, resource: textureView0},
  ],
});
let commandEncoder105 = device0.createCommandEncoder({});
let textureView91 = texture35.createView({format: 'r32sint'});
let sampler17 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 93.46,
  lodMaxClamp: 93.47,
});
try {
renderBundleEncoder10.setBindGroup(0, bindGroup29);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder91.copyTextureToTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 6, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture96,
  mipLevel: 0,
  origin: {x: 5, y: 12, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer95 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder106 = device0.createCommandEncoder({});
let externalTexture10 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder13.setBindGroup(3, bindGroup24);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer69, 'uint16', 4, 49);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer72, 'uint16', 6, 1);
} catch {}
try {
commandEncoder26.copyBufferToBuffer(buffer59, 0, buffer11, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer94, 224, new Uint32Array(6245).map((_, i) => i * 1), 577, 104);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData15,
  origin: { x: 1, y: 1 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder12.setBindGroup(3, bindGroup29);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(90);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup29, new Uint32Array(1553), 398, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(6, buffer17, 40);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(110); };
} catch {}
let commandEncoder107 = device0.createCommandEncoder({});
try {
computePassEncoder18.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer62);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer60, 'uint32', 4, 6);
} catch {}
try {
commandEncoder88.popDebugGroup();
} catch {}
let commandEncoder108 = device0.createCommandEncoder();
try {
renderBundleEncoder19.setIndexBuffer(buffer57, 'uint16', 2, 8);
} catch {}
let commandEncoder109 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder19.setBindGroup(1, bindGroup27, new Uint32Array(379), 162, 1);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(3, buffer53, 0, 16);
} catch {}
try {
commandEncoder86.copyBufferToBuffer(buffer55, 24, buffer70, 0, 0);
} catch {}
try {
commandEncoder61.resolveQuerySet(querySet0, 40, 0, buffer48, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 19, z: 15},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 77, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 122,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 123,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 256,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 325,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 372,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
  ],
});
let autogeneratedBindGroupLayout6 = pipeline8.getBindGroupLayout(0);
let buffer96 = device0.createBuffer({size: 50, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder110 = device0.createCommandEncoder({});
let textureView92 = texture103.createView({arrayLayerCount: 1});
try {
renderBundleEncoder9.setVertexBuffer(3, buffer58);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(6); };
} catch {}
let commandEncoder111 = device0.createCommandEncoder({});
try {
renderPassEncoder18.setIndexBuffer(buffer24, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup15, new Uint32Array(48), 12, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer12, 'uint32', 44, 27);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(3, buffer58);
} catch {}
try {
renderPassEncoder12.label = '\uaeab\u881f\u0867\u0f79\u{1fd05}\ue959\u84f4\u9570\u0fb3\u1719\u{1fb74}';
} catch {}
try {
computePassEncoder6.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline7);
} catch {}
try {
commandEncoder35.copyBufferToBuffer(buffer75, 112, buffer69, 20, 20);
} catch {}
try {
commandEncoder81.copyTextureToTexture({
  texture: texture82,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture103,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder112 = device0.createCommandEncoder();
let sampler18 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', magFilter: 'linear', lodMaxClamp: 98.77});
try {
renderPassEncoder14.setBindGroup(1, bindGroup4, new Uint32Array(316), 32, 0);
} catch {}
try {
commandEncoder84.resolveQuerySet(querySet1, 5, 1, buffer96, 0);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(95); };
} catch {}
try {
  await promise11;
} catch {}
let bindGroup31 = device0.createBindGroup({
  label: '\u438f\u{1f652}\u0cc5',
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 82, resource: {buffer: buffer76}},
    {binding: 144, resource: {buffer: buffer73}},
    {binding: 0, resource: textureView3},
    {binding: 3, resource: externalTexture6},
    {binding: 37, resource: {buffer: buffer68}},
    {binding: 1, resource: textureView55},
    {binding: 436, resource: externalTexture2},
  ],
});
let commandEncoder113 = device0.createCommandEncoder({});
let texture104 = device0.createTexture({
  size: [160, 120, 661],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView93 = texture29.createView({baseArrayLayer: 27, arrayLayerCount: 8});
let computePassEncoder24 = commandEncoder79.beginComputePass();
try {
computePassEncoder1.setBindGroup(2, bindGroup16);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer92);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: videoFrame2,
  origin: { x: 10, y: 25 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 5, y: 16, z: 9},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 9, height: 43, depthOrArrayLayers: 0});
} catch {}
let buffer97 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder114 = device0.createCommandEncoder({});
let textureView94 = texture78.createView({dimension: 'cube', baseArrayLayer: 1});
let externalTexture11 = device0.importExternalTexture({source: videoFrame2});
try {
renderBundleEncoder2.setIndexBuffer(buffer72, 'uint16', 6, 10);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline5);
} catch {}
try {
buffer61.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
let pipeline10 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}});
let autogeneratedBindGroupLayout7 = pipeline3.getBindGroupLayout(3);
try {
device0.pushErrorScope('internal');
} catch {}
try {
renderBundleEncoder13.insertDebugMarker('\u08a1');
} catch {}
let bindGroup32 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 0, resource: {buffer: buffer75}},
    {binding: 4, resource: textureView60},
    {binding: 630, resource: textureView16},
    {binding: 1, resource: externalTexture8},
    {binding: 64, resource: textureView17},
  ],
});
try {
computePassEncoder5.setBindGroup(1, bindGroup28, new Uint32Array(760), 540, 0);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup7, new Uint32Array(1746), 400, 0);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer61, 'uint32', 12, 12);
} catch {}
try {
commandEncoder82.copyTextureToTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 4, y: 11, z: 10},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder17.pushDebugGroup('\u00eb');
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: videoFrame2,
  origin: { x: 27, y: 65 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 17, y: 30, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 20, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(4); };
} catch {}
let texture105 = device0.createTexture({
  size: {width: 40, height: 30, depthOrArrayLayers: 53},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder16.setPipeline(pipeline0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(96); };
} catch {}
let offscreenCanvas2 = new OffscreenCanvas(15, 416);
let buffer98 = device0.createBuffer({size: 608, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let texture106 = device0.createTexture({
  size: [160, 120, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture107 = device0.createTexture({size: [60, 60, 24], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder6.beginOcclusionQuery(109);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(5, buffer64, 0, 6);
} catch {}
try {
device0.queue.submit([]);
} catch {}
document.body.prepend(canvas1);
let texture108 = device0.createTexture({
  size: {width: 120, height: 120, depthOrArrayLayers: 49},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder4.beginOcclusionQuery(12);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer60, 'uint16', 18, 1);
} catch {}
try {
buffer13.unmap();
} catch {}
let textureView95 = texture12.createView({
  label: '\u001e\u{1f975}\u02e2\u02b9\udde3\u0228\u4394\u0b36',
  dimension: '2d-array',
  aspect: 'all',
  baseMipLevel: 0,
  arrayLayerCount: 1,
});
let texture109 = device0.createTexture({
  size: [80, 60, 1],
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView96 = texture30.createView({});
let sampler19 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 45.26,
  lodMaxClamp: 60.98,
  compare: 'equal',
  maxAnisotropy: 4,
});
try {
computePassEncoder2.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder17.popDebugGroup();
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u553a');
} catch {}
try {
device0.queue.writeBuffer(buffer93, 20, new Float32Array(652).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8610)), 6, 32);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(2); };
} catch {}
let buffer99 = device0.createBuffer({size: 327, usage: GPUBufferUsage.UNIFORM});
let textureView97 = texture106.createView({dimension: '2d-array', baseMipLevel: 0});
let textureView98 = texture12.createView({format: 'rg11b10ufloat', arrayLayerCount: 1});
try {
renderPassEncoder14.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer15, 'uint32', 16, 30);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline1);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let imageData19 = new ImageData(8, 128);
let textureView99 = texture108.createView({dimension: '3d'});
let texture110 = device0.createTexture({
  size: [120, 120, 34],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder25 = commandEncoder85.beginComputePass({timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 3}});
try {
renderBundleEncoder18.setBindGroup(2, bindGroup24, new Uint32Array(233), 5, 0);
} catch {}
try {
commandEncoder48.copyBufferToBuffer(buffer46, 0, buffer72, 8, 8);
} catch {}
let pipeline11 = await promise3;
try {
adapter0.label = '\uc904\u0cfd\u{1fc1a}\u0c33\u{1fece}\uc62f\u2d34\u{1f79f}';
} catch {}
let commandEncoder115 = device0.createCommandEncoder({});
let texture111 = device0.createTexture({
  size: [40],
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder19.setBindGroup(0, bindGroup12, []);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline5);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline12 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 664,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint8x4', offset: 32, shaderLocation: 11},
          {format: 'unorm16x2', offset: 136, shaderLocation: 2},
          {format: 'sint32', offset: 104, shaderLocation: 14},
          {format: 'uint32x2', offset: 8, shaderLocation: 5},
          {format: 'sint32x4', offset: 36, shaderLocation: 0},
          {format: 'snorm16x4', offset: 52, shaderLocation: 6},
          {format: 'snorm16x4', offset: 88, shaderLocation: 10},
          {format: 'sint8x4', offset: 8, shaderLocation: 3},
          {format: 'sint32x4', offset: 32, shaderLocation: 8},
          {format: 'uint8x4', offset: 56, shaderLocation: 4},
          {format: 'float32x2', offset: 36, shaderLocation: 12},
          {format: 'snorm16x4', offset: 208, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 9},
          {format: 'sint32x4', offset: 40, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
let gpuCanvasContext3 = offscreenCanvas2.getContext('webgpu');
let img0 = await imageWithData(43, 26, '#10101010', '#20202020');
let autogeneratedBindGroupLayout8 = pipeline9.getBindGroupLayout(1);
let texture112 = device0.createTexture({
  size: {width: 160},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder25.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline5);
} catch {}
try {
  await promise13;
} catch {}
let adapter1 = await navigator.gpu.requestAdapter({powerPreference: 'high-performance'});
let bindGroup33 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [
    {binding: 37, resource: {buffer: buffer88}},
    {binding: 436, resource: externalTexture4},
    {binding: 144, resource: {buffer: buffer88}},
  ],
});
let textureView100 = texture111.createView({});
try {
renderPassEncoder4.setIndexBuffer(buffer60, 'uint32', 4, 4);
} catch {}
try {
commandEncoder61.clearBuffer(buffer97);
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let buffer100 = device0.createBuffer({size: 228, usage: GPUBufferUsage.INDIRECT});
let pipeline13 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
document.body.prepend(canvas0);
offscreenCanvas2.width = 1208;
let texture113 = device0.createTexture({size: [60], dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_DST});
let textureView101 = texture5.createView({arrayLayerCount: 1});
let renderPassEncoder22 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView80,
  clearValue: { r: -347.8, g: -154.2, b: -74.79, a: 283.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 411999850,
});
try {
renderPassEncoder7.setIndexBuffer(buffer76, 'uint32', 16, 35);
} catch {}
try {
commandEncoder26.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 536 */
  offset: 536,
  bytesPerRow: 11520,
  buffer: buffer77,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 12, y: 2, z: 0},
  aspect: 'all',
}, {width: 6, height: 13, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture8.label = '\u05cf\u88e3\u{1f9d3}\u8b2d';
} catch {}
try {
computePassEncoder10.setBindGroup(1, bindGroup29);
} catch {}
try {
computePassEncoder8.setBindGroup(3, bindGroup5, new Uint32Array(1585), 42, 0);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(2, buffer64, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: imageData15,
  origin: { x: 6, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 3, y: 9, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout9 = pipeline11.getBindGroupLayout(1);
let texture114 = device0.createTexture({
  label: '\u3de0\u079b\u3dc4\u576b\u093d\u567e\u{1fb9c}',
  size: {width: 80, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView102 = texture109.createView({dimension: '2d-array'});
try {
computePassEncoder8.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer89, 'uint16', 102, 133);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer47, 'uint16', 26, 13);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer63, 184);
} catch {}
let bindGroup34 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 1, resource: sampler7}, {binding: 70, resource: {buffer: buffer99, size: 262}}],
});
try {
computePassEncoder7.setBindGroup(2, bindGroup1, new Uint32Array(641), 75, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer17, 'uint16', 6, 11);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(3, buffer17, 4, 40);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer17, 'uint16', 32, 84);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(1, buffer55);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING});
} catch {}
let pipeline14 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}});
let buffer101 = device0.createBuffer({
  label: '\u{1f7c9}\u{1fcce}',
  size: 136,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
try {
computePassEncoder0.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer62);
} catch {}
try {
renderBundleEncoder18.setBindGroup(2, bindGroup15);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(7, buffer62, 16);
} catch {}
let arrayBuffer8 = buffer48.getMappedRange(56, 0);
try {
  await promise12;
} catch {}
let autogeneratedBindGroupLayout10 = pipeline0.getBindGroupLayout(0);
let commandEncoder116 = device0.createCommandEncoder({});
let textureView103 = texture23.createView({});
try {
computePassEncoder1.setBindGroup(3, bindGroup16, new Uint32Array(2044), 453, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(36);
} catch {}
try {
commandEncoder88.copyTextureToTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture103,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer55, 4);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(1, buffer92, 0, 30);
} catch {}
let buffer102 = device0.createBuffer({
  size: 84,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder117 = device0.createCommandEncoder({});
let textureView104 = texture13.createView({format: 'bgra8unorm', arrayLayerCount: 1});
try {
renderPassEncoder8.setVertexBuffer(4, buffer62, 4, 6);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 20, y: 20, z: 3},
  aspect: 'all',
}, new Uint8Array(1_146_817).fill(35), /* required buffer size: 1_146_817 */
{offset: 209, bytesPerRow: 308, rowsPerImage: 169}, {width: 58, height: 5, depthOrArrayLayers: 23});
} catch {}
let textureView105 = texture84.createView({});
try {
computePassEncoder18.setBindGroup(2, bindGroup16, []);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
commandEncoder112.copyTextureToTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture67,
  mipLevel: 0,
  origin: {x: 0, y: 7, z: 1},
  aspect: 'all',
},
{width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder32.resolveQuerySet(querySet2, 119, 1, buffer46, 0);
} catch {}
try {
computePassEncoder7.setBindGroup(3, bindGroup24, new Uint32Array(298), 74, 0);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer98, 'uint32', 16, 315);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer96, 40, 2);
} catch {}
document.body.prepend(canvas1);
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 82,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 436,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let bindGroup35 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout6,
  entries: [{binding: 37, resource: {buffer: buffer59, offset: 0}}, {binding: 82, resource: {buffer: buffer68}}],
});
let buffer103 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC});
let textureView106 = texture95.createView({aspect: 'all'});
let sampler20 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  lodMinClamp: 24.56,
  compare: 'always',
});
try {
renderPassEncoder16.setBindGroup(1, bindGroup21);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
buffer103.unmap();
} catch {}
let pipeline15 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}});
try {
  await promise14;
} catch {}
let device1 = await adapter1.requestDevice({
  defaultQueue: {},
  requiredFeatures: [
    'depth-clip-control',
    'texture-compression-etc2',
    'texture-compression-astc',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'float32-blendable',
    'float16-renderable',
    'float32-renderable',
    'core-features-and-limits',
  ],
  requiredLimits: {
    maxStorageBufferBindingSize: 248789522,
    maxStorageTexturesPerShaderStage: 4,
    maxTextureArrayLayers: 256,
    maxUniformBufferBindingSize: 28001587,
    maxVertexBuffers: 8,
  },
});
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'film', transfer: 'gamma22curve'} });
let buffer104 = device0.createBuffer({
  size: 196,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder118 = device0.createCommandEncoder({});
let texture115 = device0.createTexture({
  size: [120, 120, 49],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView107 = texture82.createView({mipLevelCount: 1});
try {
device0.queue.writeBuffer(buffer50, 4, new DataView(new ArrayBuffer(76112)), 5795, 0);
} catch {}
let imageData20 = new ImageData(64, 20);
let texture116 = device0.createTexture({
  label: '\u00fe\uf43b\u0f53\u060b\u0a28',
  size: [128],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint16', 0, 8);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(3, buffer62, 0, 9);
} catch {}
try {
commandEncoder102.resolveQuerySet(querySet2, 11, 10, buffer74, 0);
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u115b');
} catch {}
try {
device0.queue.writeBuffer(buffer101, 8, new DataView(new ArrayBuffer(3834)), 308, 0);
} catch {}
let bindGroup36 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 144, resource: {buffer: buffer70}}, {binding: 436, resource: externalTexture8}],
});
let texture117 = device0.createTexture({
  size: {width: 80, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder5.setBindGroup(1, bindGroup6, new Uint32Array(999), 63, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer102, 'uint16', 6, 9);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline7);
} catch {}
try {
commandEncoder78.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 456 */
  offset: 456,
  bytesPerRow: 47872,
  rowsPerImage: 356,
  buffer: buffer75,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 10, y: 1, z: 0},
  aspect: 'all',
}, {width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup37 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 144, resource: {buffer: buffer74}}, {binding: 436, resource: externalTexture7}],
});
try {
renderPassEncoder6.beginOcclusionQuery(20);
} catch {}
try {
renderBundleEncoder6.insertDebugMarker('\uce71');
} catch {}
try {
device0.queue.writeBuffer(buffer55, 0, new Uint32Array(8856).map((_, i) => i * 1), 43, 0);
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(113); };
} catch {}
document.body.append(img0);
let bindGroup38 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 3, resource: externalTexture2},
    {binding: 436, resource: externalTexture1},
    {binding: 0, resource: textureView0},
    {binding: 37, resource: {buffer: buffer59}},
    {binding: 82, resource: {buffer: buffer79}},
    {binding: 144, resource: {buffer: buffer74}},
    {binding: 1, resource: textureView4},
  ],
});
let commandEncoder119 = device0.createCommandEncoder({});
try {
computePassEncoder19.setBindGroup(2, bindGroup12, new Uint32Array(1057), 17, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup17);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup13, new Uint32Array(426), 37, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup7);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup8, new Uint32Array(861), 31, 0);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(7, buffer73, 24, 23);
} catch {}
try {
commandEncoder75.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 36 */
  offset: 36,
  buffer: buffer67,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let externalTexture12 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'});
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer98, 'uint16', 230, 63);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer64, 0, 1);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup31, new Uint32Array(192), 71, 0);
} catch {}
document.body.prepend(img0);
offscreenCanvas1.height = 2495;
let buffer105 = device1.createBuffer({size: 472, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let texture118 = device1.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 20},
  format: 'eac-rg11unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView108 = texture118.createView({dimension: '2d', baseArrayLayer: 1});
let renderBundleEncoder23 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', depthReadOnly: true});
try {
  await promise15;
} catch {}
let texture119 = device0.createTexture({
  size: [128, 128, 26],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture120 = device0.createTexture({
  size: [160, 120, 661],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let texture121 = gpuCanvasContext2.getCurrentTexture();
let textureView109 = texture59.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3});
try {
renderPassEncoder10.setIndexBuffer(buffer75, 'uint32', 80, 58);
} catch {}
try {
buffer48.unmap();
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'film', transfer: 'pq'} });
let commandEncoder120 = device1.createCommandEncoder({});
let texture122 = device1.createTexture({
  size: [300, 40, 26],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'astc-10x8-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture123 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture13 = device1.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'});
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let bindGroup39 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 70, resource: {buffer: buffer70}}]});
let texture124 = device0.createTexture({
  size: [20, 15, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder8.setIndexBuffer(buffer69, 'uint32', 20, 8);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer69, 'uint32', 0, 4);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let textureView110 = texture118.createView({dimension: 'cube', baseArrayLayer: 2});
let textureView111 = texture123.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
try {
device1.queue.writeBuffer(buffer105, 200, new Float32Array(2613).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.418)), 539, 12);
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(207, 288);
let texture125 = device0.createTexture({
  size: [60, 60, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView112 = texture1.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder17.setBindGroup(3, bindGroup5, new Uint32Array(221), 29, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer89, 'uint16', 248, 44);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 0, new Float32Array(6613).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.301)), 545, 24);
} catch {}
let pipeline16 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
await gc();
let commandEncoder121 = device1.createCommandEncoder({});
let textureView113 = texture118.createView({label: '\ue92a\u{1f941}\u0b11', dimension: 'cube', aspect: 'all', baseArrayLayer: 1});
try {
offscreenCanvas3.getContext('webgpu');
} catch {}
let bindGroup40 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: textureView80}]});
let commandEncoder122 = device0.createCommandEncoder({});
let texture126 = device0.createTexture({
  size: {width: 80, height: 60, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder10.setBindGroup(3, bindGroup25);
} catch {}
try {
computePassEncoder20.setBindGroup(2, bindGroup19, new Uint32Array(1615), 106, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer58);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline5);
} catch {}
let commandEncoder123 = device1.createCommandEncoder({});
let computePassEncoder26 = commandEncoder123.beginComputePass();
try {
device1.queue.writeBuffer(buffer105, 12, new Uint32Array(6992).map((_, i) => i * 9), 1699, 24);
} catch {}
let veryExplicitBindGroupLayout14 = device1.createBindGroupLayout({
  entries: [
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let pipelineLayout5 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout14]});
let buffer106 = device1.createBuffer({size: 52, usage: GPUBufferUsage.UNIFORM});
let imageData21 = new ImageData(132, 120);
let buffer107 = device0.createBuffer({size: 132, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let textureView114 = texture124.createView({});
let textureView115 = texture87.createView({});
let sampler21 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.43,
  maxAnisotropy: 13,
});
try {
commandEncoder90.insertDebugMarker('\u0169');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData17,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder27 = commandEncoder121.beginComputePass();
let promise16 = device1.queue.onSubmittedWorkDone();
let commandEncoder124 = device0.createCommandEncoder();
let textureView116 = texture119.createView({arrayLayerCount: 1});
let texture127 = device0.createTexture({
  size: {width: 160},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder16.setBindGroup(0, bindGroup31);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer47, 'uint16', 4, 42);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let pipelineLayout6 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout14, veryExplicitBindGroupLayout14]});
let buffer108 = device1.createBuffer({size: 4, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let computePassEncoder28 = commandEncoder120.beginComputePass();
let sampler22 = device1.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 77.59});
let bindGroup41 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [
    {binding: 144, resource: {buffer: buffer70}},
    {binding: 436, resource: externalTexture2},
    {binding: 37, resource: {buffer: buffer88}},
  ],
});
let commandEncoder125 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({
  size: [60, 60, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder10.setVertexBuffer(2, buffer104);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer75, 0, 51);
} catch {}
try {
  await shaderModule3.getCompilationInfo();
} catch {}
try {
device0.queue.writeBuffer(buffer59, 32, new Uint32Array(1614).map((_, i) => i * 7), 502, 0);
} catch {}
let veryExplicitBindGroupLayout15 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let buffer109 = device1.createBuffer({size: 52, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture129 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 108},
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
try {
device1.pushErrorScope('internal');
} catch {}
try {
renderBundleEncoder23.insertDebugMarker('\u2dea');
} catch {}
try {
device1.queue.writeBuffer(buffer105, 116, new BigInt64Array(63046).map((_, i) => BigInt(i - 0)), 8861, 12);
} catch {}
let promise17 = device1.queue.onSubmittedWorkDone();
try {
gpuCanvasContext3.unconfigure();
} catch {}
let bindGroup42 = device0.createBindGroup({layout: autogeneratedBindGroupLayout9, entries: [{binding: 37, resource: {buffer: buffer79}}]});
try {
computePassEncoder23.setBindGroup(2, bindGroup12, new Uint32Array(1776), 215, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer47, 'uint32', 28, 15);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline0);
} catch {}
let promise18 = device0.queue.onSubmittedWorkDone();
let textureView117 = texture104.createView({dimension: '3d', mipLevelCount: 1, arrayLayerCount: 1});
try {
renderBundleEncoder7.setVertexBuffer(3, buffer58, 0);
} catch {}
let veryExplicitBindGroupLayout16 = device1.createBindGroupLayout({
  entries: [
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let buffer110 = device1.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture130 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 39},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
buffer106.unmap();
} catch {}
let textureView118 = texture86.createView({});
try {
renderPassEncoder9.setIndexBuffer(buffer12, 'uint16', 20, 6);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(1, buffer73, 0);
} catch {}
try {
commandEncoder122.resolveQuerySet(querySet2, 71, 0, buffer48, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer64, 8, new Uint32Array(35958).map((_, i) => i * 4), 5990, 0);
} catch {}
let shaderModule5 = device1.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires readonly_and_readwrite_storage_textures;

struct T7 {
  f0: array<u32>,
}

struct T8 {
  f0: array<u32>,
}

struct VertexInput18 {
  @builtin(instance_index) instance_index: u32,
  @location(4) location_4: vec2i,
  @location(11) @interpolate(flat) location_11: vec2u,
  @location(6) location_6: vec2f,
  @location(15) location_15: vec4i,
  @location(7) location_7: vec4f,
}

/* used global variables: tex12 */
fn fn0(a0: array<vec2h, 1>) -> vec2f {
  var out: vec2f;
  out = vec2f((vec4i(unconst_i32(289858706), unconst_i32(307408952), unconst_i32(-489909684), unconst_i32(18296049)) - unconst_i32(103888462)).aa);
  if bool(a0[0][0]) {
  out += vec2f(f32(a0[unconst_u32(1587373505)][unconst_u32(2615215829)]));
}
  let vf61: vec3h = fract(vec3h(unconst_f16(6642.7), unconst_f16(578.7), unconst_f16(7290.2)));
  var vf62: vec3u = max(vec3u(unconst_u32(349778817), unconst_u32(868780995), unconst_u32(111315187)), vec3u(unconst_u32(400091667), unconst_u32(11433906), unconst_u32(1987046130)));
  vf62 += textureDimensions(tex12, unconst_i32(101315642)).rgr;
  var vf63: vec2h = fma(vec2h(unconst_f16(4305.4), unconst_f16(-28622.9)), vec2h(unconst_f16(2895.9), unconst_f16(26659.8)), vec2h(unconst_f16(15182.3), unconst_f16(9852.5)));
  var vf64: vec4i = (vec4i(unconst_i32(399790447), unconst_i32(367017143), unconst_i32(363037711), unconst_i32(-398351061)) - unconst_i32(907093763));
  return out;
  _ = tex12;
}

fn unconst_f16(v: f16) -> f16 { return v; }

struct T5 {
  @align(16) f0: array<array<array<array<array<atomic<i32>, 1>, 1>, 1>, 1>>,
}

struct T11 {
  f0: T6,
}

struct VertexInput19 {
  @location(12) @interpolate(flat, first) location_12: u32,
  @location(13) location_13: vec4u,
  @location(8) location_8: vec2f,
}

struct T2 {
  @size(16) f0: atomic<i32>,
}

struct T14 {
  @size(30) f0: T9,
}

struct FragmentOutput5 {
  @location(0) location_0: vec4i,
}

struct VertexInput22 {
  @location(9) @interpolate(flat, first) location_9: i32,
}

struct T1 {
  f0: array<T0>,
}

struct T9 {
  f0: T4,
}

@group(0) @binding(0) var<storage, read_write> buffer111: array<array<array<array<array<array<array<f16, 5>, 1>, 3>, 1>, 1>, 1>>;

struct T6 {
  @align(16) f0: array<array<array<T0, 1>, 1>, 1>,
}

struct T12 {
  @size(224) f0: atomic<i32>,
  @size(512) f1: vec4u,
  @size(80) f2: T11,
}

/* used global variables: buffer111, tex12 */
@must_use 
fn fn1() -> array<vec2i, 1> {
  var out: array<vec2i, 1>;
  let ptr70: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(643924664)][0][0][2][0];
  let vf65: vec4i = firstLeadingBit(vec4i(unconst_i32(682571127), unconst_i32(393209740), unconst_i32(106090254), unconst_i32(4383847)));
  let ptr71: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][0][0][2][unconst_u32(15859411)];
  out[u32(buffer111[arrayLength(&buffer111)][0][0][0][2][u32((*&buffer111)[unconst_u32(1039356146)][0][unconst_u32(323408289)][u32(buffer111[unconst_u32(63690972)][0][unconst_u32(3081497611)][unconst_u32(1740465393)][unconst_u32(1425150364)][unconst_u32(2114995716)][unconst_u32(1078259474)])][2][0][unconst_u32(646813264)])][unconst_u32(341317359)])] = vec2i(i32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(1943521287)][0][unconst_u32(89857005)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(1271488946)][unconst_u32(562457008)][u32((*&buffer111)[arrayLength(&(*&buffer111))][0][0][unconst_u32(410878851)][unconst_u32(153557544)][unconst_u32(27942796)][4])][2][unconst_u32(389756695)][4])][0][unconst_u32(2588479233)]));
  let ptr72: ptr<storage, array<array<array<f16, 5>, 1>, 3>, read_write> = &buffer111[unconst_u32(1085810)][unconst_u32(739077512)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(30984428)][unconst_u32(960097958)][unconst_u32(201522194)][unconst_u32(564654120)][0][unconst_u32(471396599)])][unconst_u32(193368784)];
  fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(405827118)][unconst_u32(938597793)][0][0][unconst_u32(220015577)][unconst_u32(62099186)][4])));
  let ptr73: ptr<storage, f16, read_write> = &buffer111[arrayLength(&buffer111)][u32((*&buffer111)[unconst_u32(1310583091)][0][unconst_u32(1562437151)][unconst_u32(451190856)][2][0][4])][unconst_u32(792481166)][unconst_u32(967486374)][unconst_u32(331700465)][unconst_u32(2154848740)][4];
  let ptr74: ptr<storage, array<f16, 5>, read_write> = &buffer111[arrayLength(&buffer111)][unconst_u32(606494818)][0][0][2][unconst_u32(874790891)];
  loop {
  var vf66 = fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(557737620)][0][0][0][2][unconst_u32(81580988)][4])));
  let ptr75: ptr<storage, array<array<f16, 5>, 1>, read_write> = &(*&buffer111)[unconst_u32(457665734)][0][0][0][2];
  out[unconst_u32(1403944086)] = vec2i(i32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(921500466)][unconst_u32(829211125)][unconst_u32(501615644)][unconst_u32(1046812162)][unconst_u32(61595907)][4]));
  var vf67 = fn0(array<vec2h, 1>(vec2h((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(58764675)][0][0][u32(buffer111[arrayLength(&buffer111)][0][unconst_u32(433788846)][0][2][0][4])][0][unconst_u32(28561152)])));
  out[unconst_u32(75752975)] *= vec2i(i32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(17019303)][0][0][u32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(31283698)][0][0][2][unconst_u32(346094354)][unconst_u32(302795276)])][0][4]));
  out[unconst_u32(92785855)] = vec2i(i32(buffer111[arrayLength(&buffer111)][0][0][unconst_u32(647604630)][2][0][4]));
  break;
  _ = buffer111;
  _ = tex12;
}
  return out;
  _ = tex12;
  _ = buffer111;
}

struct VertexInput21 {
  @location(3) location_3: u32,
  @location(2) @interpolate(flat, sample) location_2: vec2u,
}

fn unconst_i32(v: i32) -> i32 { return v; }

fn unconst_u32(v: u32) -> u32 { return v; }

struct VertexInput20 {
  @builtin(vertex_index) vertex_index: u32,
}

struct T10 {
  f0: array<atomic<i32>>,
}

struct T4 {
  @align(16) @size(16) f0: vec2h,
}

struct T3 {
  @size(512) f0: i32,
  @size(320) f1: vec2f,
}

fn unconst_bool(v: bool) -> bool { return v; }

struct T13 {
  f0: T9,
  f1: array<array<atomic<i32>, 1>>,
}

fn unconst_f32(v: f32) -> f32 { return v; }

struct VertexInput23 {
  @location(14) location_14: vec2u,
}

@group(0) @binding(4) var tex12: texture_cube<f32>;

struct T0 {
  f0: vec4<bool>,
}

/* zero global variables used */
@vertex
fn vertex4(@location(10) location_10: vec4u, @location(5) @interpolate(flat, centroid) location_5: vec4u, a2: VertexInput18, a3: VertexInput19, @location(0) @interpolate(linear, either) location_0: f16, a5: VertexInput20, @location(1) @interpolate(flat) location_1: vec2u, a7: VertexInput21, a8: VertexInput22, a9: VertexInput23) -> @builtin(position) vec4f {
  var out: vec4f;
  out *= vec4f(f32(a5.vertex_index));
  while bool(location_10[unconst_u32(70099125)]) {
  out = (bitcast<f32>(pack4x8snorm(vec4f(unconst_f32(0.09215), unconst_f32(0.4044), unconst_f32(0.07711), unconst_f32(0.1160e38)))) / vec2f(unconst_f32(0.1348), unconst_f32(0.1484))).yyxx;
  out *= unpack4x8unorm(pack4xI8(vec4i(unconst_i32(113236913), unconst_i32(274219760), unconst_i32(1108743471), unconst_i32(185819856))));
  out = vec4f(f32(a8.location_9));
  out *= bitcast<vec4f>(a2.location_15);
  break;
}
  if bool(a9.location_14.g) {
  out = vec4f(a2.location_4.yyxx.zxxz.gbba);
  let vf68: u32 = a7.location_3;
  var vf69: i32 = a2.location_4[unconst_u32(1127737024)];
}
  out += vec4f(bitcast<f32>(a5.vertex_index));
  let vf70: vec4h = exp2(vec4h(unconst_f16(4883.3), unconst_f16(-2867.1), unconst_f16(880.2), unconst_f16(19607.2)));
  let vf71: VertexInput20 = a5;
  out *= vec4f(a2.location_11.rgrr.yyzx.bbba.xyzw.aaag);
  for (var it4=bitcast<u32>(reverseBits(unconst_i32(504309695))); it4<(a9.location_14[1] & 0xfff); it4++) {
  out = bitcast<vec4f>(a3.location_13.grab.wywx.bbag);
  var vf72: f32 = a2.location_7[unconst_u32(170012059)];
  loop {
  let vf73: vec3h = reflect(vec3h(unconst_f16(21196.2), unconst_f16(15010.0), unconst_f16(8422.3)), vec3h(unconst_f16(741.6), unconst_f16(26229.8), unconst_f16(3226.9)));
  out = unpack4x8unorm(dot(vec2u(select(vec2f(unconst_f32(0.2477e24), unconst_f32(0.01440)), vec2f(unconst_f32(0.8016), unconst_f32(0.08875e36)), vec2<bool>(unconst_bool(false), unconst_bool(true))).xy), vec2u(unconst_u32(460233627), unconst_u32(153681592))));
  out = vec4f(a2.location_11.yyyy);
  out = vec4f(f32(a8.location_9));
  break;
}
  out *= vec4f(f32(pack4x8unorm(vec4f(unconst_f32(0.09238e-15), unconst_f32(0.3470e29), unconst_f32(-0.4654e27), unconst_f32(0.2288e5)))));
  out = unpack4x8unorm(location_5[unconst_u32(1123475529)]);
}
  out = vec4f(a2.location_11.yyxy.aara.yzxz.aggg.rgar);
  out = atan2(vec4f(unconst_f32(-0.5375), unconst_f32(0.00307e-14), unconst_f32(-0.08257e-15), unconst_f32(0.3993e22)), bitcast<vec4f>(a2.location_4.grgr.xwzx));
  return out;
}

/* used global variables: buffer111, tex12 */
@fragment
fn fragment6(@builtin(position) position: vec4f, @builtin(sample_index) sample_index: u32, @builtin(front_facing) front_facing: bool) -> FragmentOutput5 {
  var out: FragmentOutput5;
  while bool(buffer111[unconst_u32(907431799)][0][0][0][unconst_u32(1247149388)][0][unconst_u32(266410952)]) {
  out.location_0 -= vec4i(i32(buffer111[unconst_u32(7709429)][0][unconst_u32(597540797)][0][2][0][4]));
  let ptr76: ptr<storage, array<array<f16, 5>, 1>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][unconst_u32(464758587)][unconst_u32(210350216)][2];
  let ptr77: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(438000279)][unconst_u32(59910098)][0][unconst_u32(892743085)][unconst_u32(127763019)];
  out.location_0 -= vec4i(i32((*&buffer111)[unconst_u32(60067418)][0][0][0][2][unconst_u32(253268163)][4]));
  break;
  _ = buffer111;
}
  out.location_0 = vec4i(i32((*&buffer111)[unconst_u32(158085395)][unconst_u32(1439194488)][0][unconst_u32(21416865)][2][0][4]));
  var vf74 = fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(1374089743)][unconst_u32(1784623139)][0][0][2][0][4])));
  let ptr78: ptr<storage, array<array<f16, 5>, 1>, read_write> = &buffer111[unconst_u32(131529928)][0][unconst_u32(270996292)][unconst_u32(543779834)][2];
  vf74 = vec2f(f32((*&buffer111)[unconst_u32(3660481357)][unconst_u32(1859310776)][u32(buffer111[arrayLength(&buffer111)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(879577475)][0][0][2][0][4])][unconst_u32(428736758)][unconst_u32(682614546)][unconst_u32(49280466)][0][unconst_u32(746473576)])][unconst_u32(687549388)][2][0][4]));
  loop {
  for (var jj17=0u; jj17<3; jj17++) { buffer111[unconst_u32(1378383016)][unconst_u32(349795350)][jj17][unconst_u32(1383696797)][unconst_u32(1096619974)][u32(buffer111[arrayLength(&buffer111)][0][0][unconst_u32(19193634)][unconst_u32(827395663)][0][bitcast<u32>(position[unconst_u32(141712775)])])][unconst_u32(263588639)] = (*&buffer111)[arrayLength(&(*&buffer111))][0][unconst_u32(85785480)][0][2][0][unconst_u32(42197490)]; }
  _ = fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(1220902597)][0][unconst_u32(556878183)][unconst_u32(131649493)][u32(buffer111[arrayLength(&buffer111)][0][0][0][2][0][4])][unconst_u32(2012817572)][4])));
  let ptr79: ptr<storage, f16, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][0][0][2][0][4];
  for (var it6=u32(buffer111[unconst_u32(1303876945)][u32(buffer111[unconst_u32(1654662470)][unconst_u32(1106498075)][0][unconst_u32(327828301)][2][u32((*&buffer111)[unconst_u32(744231970)][unconst_u32(579885222)][unconst_u32(1383472216)][0][unconst_u32(792527395)][unconst_u32(109612167)][unconst_u32(710629584)])][4])][unconst_u32(677446380)][0][2][0][4]); it6<(textureDimensions(tex12, i32(pack4xI8(vec4i(i32((*&buffer111)[arrayLength(&(*&buffer111)) - 1][0][0][0][2][0][4])))))[0] & 0xfff); it6++) {
  fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_i32(261567886)][0][0][0][2][0][4])));
  out.location_0 &= vec4i(i32((*&buffer111)[unconst_u32(2372121395)][unconst_u32(165747988)][unconst_u32(132810931)][unconst_u32(712119666)][unconst_u32(1475908790)][0][4]));
  let ptr80: ptr<storage, f16, read_write> = &(*&buffer111)[unconst_u32(46731547)][0][0][0][2][0][unconst_u32(505681395)];
  for (var it5=u32((*&buffer111)[unconst_u32(811423483)][0][0][unconst_u32(142029526)][2][unconst_u32(3457307)][4]); it5<(u32(buffer111[arrayLength(&buffer111)][unconst_u32(750363586)][unconst_u32(180267308)][0][unconst_u32(2188301839)][0][4]) & 0xfff); it5++) {
  let ptr81: ptr<storage, f16, read_write> = &buffer111[arrayLength(&buffer111)][0][u32((*&buffer111)[unconst_u32(2374767596)][unconst_u32(913301243)][0][unconst_u32(1521182977)][2][unconst_u32(87665970)][4])][0][2][0][4];
  buffer111[unconst_u32(887641115)][unconst_u32(1363983629)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(307859812)][0][unconst_u32(1287056532)][unconst_u32(514222944)][0][4])][unconst_u32(1198295125)][unconst_u32(716002818)][u32(buffer111[unconst_u32(86432740)][unconst_u32(918854974)][0][unconst_u32(645342376)][2][unconst_u32(418372328)][u32((*&buffer111)[u32(buffer111[arrayLength(&buffer111)][u32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(40780699)][unconst_u32(202555959)][0][2][0][4])][0][0][unconst_u32(592286634)][0][4])][unconst_u32(1646422398)][0][0][u32(buffer111[unconst_u32(194949726)][0][0][unconst_u32(210674350)][unconst_u32(28114972)][0][4])][0][unconst_u32(1270059922)])])][unconst_u32(515258050)] = buffer111[arrayLength(&buffer111)][0][0][0][unconst_u32(531388967)][0][unconst_u32(498219599)];
  let ptr82: ptr<storage, array<f16, 5>, read_write> = &buffer111[arrayLength(&buffer111)][0][0][unconst_u32(279124641)][2][unconst_u32(648844626)];
  _ = buffer111;
}
  _ = tex12;
  _ = buffer111;
}
  let ptr83: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][0][unconst_u32(380679243)][unconst_u32(186537328)][0];
  break;
  _ = buffer111;
  _ = tex12;
}
  buffer111[unconst_u32(210704401)][unconst_u32(215565526)][unconst_u32(579746955)][unconst_u32(409001149)][unconst_u32(94539270)][unconst_u32(248039869)][4] += (*&buffer111)[unconst_u32(65834513)][0][0][0][unconst_u32(709475732)][unconst_u32(1331977708)][4];
  return out;
  _ = buffer111;
  _ = tex12;
}

/* used global variables: tex12 */
@compute @workgroup_size(1, 1, 1)
fn compute5(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u) {
  var vf75: mat2x3f = (mat2x3f(unconst_f32(0.1377), unconst_f32(0.01324e16), unconst_f32(0.2363), unconst_f32(0.03664), unconst_f32(0.00042), unconst_f32(0.08610e-31)) - mat2x3f());
  fn0(array<vec2h, 1>(vec2h(unpack2x16float(unconst_u32(1900260079)))));
  vf75 += mat2x3f(bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), f32(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), f32(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]));
  fn0(array<vec2h, 1>(vec2h(vf75[unconst_i32(0)].zy)));
  vf75 = mat2x3f(bitcast<vec3f>(textureDimensions(tex12, unconst_i32(87124486)).yxx), vec3f(textureDimensions(tex12, unconst_i32(87124486)).grr.yxz));
  _ = tex12;
}`,
});
let commandEncoder126 = device1.createCommandEncoder({});
let sampler23 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.51,
  compare: 'less-equal',
  maxAnisotropy: 19,
});
let computePassEncoder29 = commandEncoder126.beginComputePass();
let renderBundleEncoder24 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8'});
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await promise18;
} catch {}
let texture131 = device1.createTexture({
  size: {width: 75, height: 10, depthOrArrayLayers: 88},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture132 = device1.createTexture({
  size: {width: 150, height: 20, depthOrArrayLayers: 1},
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder25 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', sampleCount: 1});
let pipeline17 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}});
try {
adapter0.label = '\u7d3b\uc3ef\u{1fedb}';
} catch {}
let bindGroup43 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 0, resource: {buffer: buffer109}},
    {binding: 4, resource: textureView113},
    {binding: 44, resource: {buffer: buffer106}},
  ],
});
let commandEncoder127 = device1.createCommandEncoder({});
let textureView119 = texture131.createView({dimension: '2d', baseArrayLayer: 8});
let texture133 = device1.createTexture({
  size: [75, 10, 1],
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let texture134 = gpuCanvasContext0.getCurrentTexture();
let renderBundleEncoder26 = device1.createRenderBundleEncoder({
  colorFormats: ['rgba32sint'],
  depthStencilFormat: 'stencil8',
  sampleCount: 1,
  depthReadOnly: false,
  stencilReadOnly: true,
});
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise17;
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteRp431', transfer: 'bt2020_12bit'} });
let pipelineLayout7 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout16, veryExplicitBindGroupLayout16]});
let commandEncoder128 = device1.createCommandEncoder({});
let textureView120 = texture131.createView({dimension: '2d', format: 'rgba16float', baseArrayLayer: 1});
try {
computePassEncoder28.setBindGroup(2, bindGroup43, [0]);
} catch {}
try {
renderBundleEncoder24.setBindGroup(3, bindGroup43, [0]);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
buffer108.unmap();
} catch {}
try {
device1.queue.writeBuffer(buffer105, 24, new Float16Array(14043).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.970)), 551, 36);
} catch {}
try {
  await promise16;
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte170m', transfer: 'gamma28curve'} });
let textureView121 = texture111.createView({format: 'rgba16float'});
let textureView122 = texture103.createView({baseArrayLayer: 0});
try {
renderBundleEncoder2.setIndexBuffer(buffer15, 'uint32', 48, 18);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: imageData7,
  origin: { x: 0, y: 12 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 16, y: 3, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 2, depthOrArrayLayers: 0});
} catch {}
let buffer113 = device1.createBuffer({size: 168, usage: GPUBufferUsage.STORAGE});
let commandEncoder129 = device1.createCommandEncoder({});
let querySet3 = device1.createQuerySet({type: 'occlusion', count: 246});
let texture135 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 7},
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder30 = commandEncoder127.beginComputePass();
try {
computePassEncoder28.setPipeline(pipeline17);
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires readonly_and_readwrite_storage_textures;

override override11 = false;

@group(0) @binding(177) var<uniform> buffer115: array<array<vec4f, 38>, 1>;

@group(1) @binding(383) var<storage, read_write> buffer121: array<array<i32, 38>>;

struct VertexInput30 {
  @location(12) @interpolate(flat, sample) location_12: i32,
}

override override10: i32 = 128454244;

var<workgroup> vw8: array<vec2f, 1>;

@group(1) @binding(351) var<uniform> buffer120: array<array<array<VertexInput27, 4>, 5>, 5>;

struct VertexInput33 {
  @builtin(instance_index) instance_index: u32,
}

struct FragmentInput13 {
  @location(0) @interpolate(flat, sample) location_0: vec2u,
}

@group(0) @binding(197) var<storage, read_write> buffer116: array<array<array<array<FragmentInput10, 13>, 4>, 6>>;

override override12: bool;

struct VertexInput29 {
  @location(3) location_3: u32,
}

struct VertexInput31 {
  @location(4) location_4: i32,
  @location(10) @interpolate(flat, first) location_10: vec4u,
}

struct VertexInput28 {
  @location(11) @interpolate(perspective, either) location_11: f32,
  @location(6) @interpolate(flat, either) location_6: f16,
}

struct VertexInput27 {
  @location(14) @interpolate(perspective, centroid) location_14: vec4f,
}

struct FragmentInput12 {
  @location(6) location_6: vec4f,
}

struct FragmentInput8 {
  @location(7) location_7: f32,
  @location(10) @interpolate(flat, first) location_10: vec2u,
  @location(11) @interpolate(flat, sample) location_11: vec4i,
  @location(14) @interpolate(perspective, either) location_14: f32,
}

struct T0 {
  @size(200) f0: i32,
  f1: vec2i,
  @size(88) f2: array<array<array<vec4i, 1>, 5>, 1>,
}

@group(2) @binding(0) var<storage, read_write> buffer122: array<array<array<array<VertexInput31, 16>, 1>, 7>>;

@group(1) @binding(4) var<storage, read_write> buffer119: array<FragmentInput8>;

struct VertexInput34 {
  @builtin(vertex_index) vertex_index: u32,
}

struct VertexInput26 {
  @location(2) @interpolate(flat) location_2: vec2i,
  @location(8) @interpolate(linear) location_8: f32,
}

struct FragmentInput11 {
  @location(13) location_13: vec2f,
}

fn unconst_f32(v: f32) -> f32 { return v; }

fn unconst_f16(v: f16) -> f16 { return v; }

struct FragmentInput15 {
  @builtin(position) position: vec4f,
}

struct VertexInput32 {
  @location(0) @interpolate(flat) location_0: vec2i,
}

@id(60121) override override13: i32 = 94900840;

fn unconst_bool(v: bool) -> bool { return v; }

var<workgroup> vw10: array<atomic<i32>, 1>;

struct FragmentInput10 {
  @location(1) location_1: f16,
}

struct VertexInput25 {
  @location(13) @interpolate(flat) location_13: vec2i,
}

var<workgroup> vw9: array<atomic<i32>, 1>;

struct FragmentOutput6 {
  @location(6) location_6: f32,
  @location(5) @interpolate(flat, centroid) location_5: vec2i,
  @location(0) @interpolate(flat, first) location_0: vec2u,
}

struct VertexOutput4 {
  @location(5) @interpolate(flat, either) location_5: u32,
  @location(3) location_3: u32,
  @location(12) location_12: vec2h,
  @location(1) location_1: vec2i,
  @location(7) @interpolate(flat) location_7: vec4i,
  @location(8) @interpolate(flat, first) location_8: vec4u,
  @location(2) location_2: vec2h,
  @builtin(position) position: vec4f,
  @location(11) @interpolate(flat, either) location_11: vec4h,
  @location(14) location_14: vec4f,
  @location(15) @interpolate(flat, sample) location_15: vec4i,
  @location(13) @interpolate(flat, centroid) location_13: vec2u,
}

fn unconst_u32(v: u32) -> u32 { return v; }

struct FragmentInput14 {
  @builtin(sample_index) sample_index: u32,
}

struct VertexInput24 {
  @location(1) location_1: vec4f,
  @location(9) @interpolate(linear) location_9: vec2h,
  @location(5) location_5: vec4u,
}

@group(0) @binding(329) var st4: texture_storage_1d<r32uint, read_write>;

fn unconst_i32(v: i32) -> i32 { return v; }

struct FragmentInput9 {
  @location(8) location_8: vec4f,
  @builtin(sample_mask) sample_mask: u32,
}

/* zero global variables used */
@vertex
fn vertex5(@location(7) @interpolate(flat) location_7: vec4i, a1: VertexInput24, @location(15) @interpolate(perspective, first) location_15: vec4h, a3: VertexInput25, a4: VertexInput26, a5: VertexInput27, a6: VertexInput28, a7: VertexInput29, a8: VertexInput30, a9: VertexInput31, a10: VertexInput32, a11: VertexInput33, a12: VertexInput34) -> VertexOutput4 {
  var out: VertexOutput4;
  var vf76: f32 = out.position[unconst_u32(1968284550)];
  let vf77: bool = override12;
  out.location_8 &= unpack4xU8(u32(a8.location_12));
  return out;
  _ = override12;
}

/* used global variables: buffer115, buffer116, buffer119, buffer120, buffer121, buffer122, st4 */
@fragment
fn fragment7(@location(9) location_9: vec4h, a1: FragmentInput8, @location(2) @interpolate(perspective, centroid) location_2: vec4f, a3: FragmentInput9, a4: FragmentInput10, a5: FragmentInput11, a6: FragmentInput12, a7: FragmentInput13, a8: FragmentInput14, a9: FragmentInput15) -> FragmentOutput6 {
  var out: FragmentOutput6;
  let ptr84: ptr<storage, VertexInput31, read_write> = &(*&buffer122)[arrayLength(&(*&buffer122))][6][unconst_u32(492999490)][unconst_u32(363742571)];
  for (var jj98=0u; jj98<40; jj98++) { buffer121[unconst_u32(187136589)][jj98] = i32(buffer116[pack4xU8Clamp(bitcast<vec4u>((*&buffer115)[unconst_u32(603020452)][37].gbga.rgaa))][5][3][unconst_u32(1423473961)].location_1); }
  let ptr85: ptr<uniform, array<array<VertexInput27, 4>, 5>> = &(*&buffer120)[4];
  let ptr86: ptr<storage, FragmentInput10, read_write> = &(*&buffer116)[arrayLength(&(*&buffer116))][unconst_u32(1061407859)][3][12];
  textureStore(st4, i32(buffer116[arrayLength(&buffer116)][unconst_u32(891994081)][3][12].location_1), vec4u(vec4u(unconst_u32(131413931), unconst_u32(2173767082), unconst_u32(217562214), unconst_u32(445102356))));
  buffer119[pack4x8unorm((*&buffer120)[4][unconst_u32(44322755)][3].location_14)].location_11 &= vec4i(bitcast<i32>((*&buffer115)[unconst_u32(349102726)][unconst_u32(232356674)][unconst_u32(775902460)]));
  let ptr87: ptr<storage, FragmentInput10, read_write> = &(*&buffer116)[arrayLength(&(*&buffer116))][unconst_u32(168456577)][unconst_u32(1173280622)][unconst_u32(225219525)];
  buffer122[unconst_u32(967170119)][bitcast<u32>((*&buffer121)[arrayLength(&(*&buffer121)) - 1][37])][unconst_u32(726373236)][unconst_u32(263959244)].location_10 = unpack4xU8(bitcast<u32>(buffer121[unconst_u32(323214340)][unconst_u32(228041540)]));
  buffer122[unconst_u32(1038716194)][unconst_u32(901652999)][unconst_u32(1471595058)][unconst_u32(1829447742)].location_4 -= i32(buffer115[0][unconst_u32(3593818318)][unconst_u32(582909744)]);
  return out;
  _ = buffer119;
  _ = st4;
  _ = buffer120;
  _ = buffer116;
  _ = buffer121;
  _ = buffer115;
  _ = buffer122;
}

/* zero global variables used */
@compute @workgroup_size(2, 1, 1)
fn compute6(@builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) {
  atomicMax(&vw9[unconst_u32(573240235)], unconst_i32(64684075));
}`,
});
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d' },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {
      binding: 285,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 401, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
  ],
});
let bindGroup44 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 3, resource: externalTexture3},
    {binding: 144, resource: {buffer: buffer74, offset: 0}},
    {binding: 1, resource: textureView8},
    {binding: 0, resource: textureView0},
    {binding: 82, resource: {buffer: buffer68}},
    {binding: 37, resource: {buffer: buffer88, size: 124}},
    {binding: 436, resource: externalTexture1},
  ],
});
let texture136 = device0.createTexture({size: [128, 128, 26], format: 'rg32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView123 = texture93.createView({dimension: '3d', format: 'r32uint'});
try {
renderBundleEncoder3.setVertexBuffer(2, buffer64);
} catch {}
await gc();
let imageData22 = new ImageData(120, 4);
let veryExplicitBindGroupLayout18 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 41,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 51,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 99,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 317, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 445,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
  ],
});
let buffer124 = device1.createBuffer({
  size: 126,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView124 = texture123.createView({mipLevelCount: 1});
let externalTexture14 = device1.importExternalTexture({source: videoFrame12});
document.body.prepend(img0);
let textureView125 = texture53.createView({});
try {
renderPassEncoder2.setVertexBuffer(0, buffer53);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer60, 'uint16', 36, 0);
} catch {}
try {
commandEncoder101.copyTextureToTexture({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 0, y: 24, z: 5},
  aspect: 'all',
},
{
  texture: texture61,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture137 = gpuCanvasContext3.getCurrentTexture();
try {
gpuCanvasContext2.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device1.queue.writeBuffer(buffer105, 28, new Float32Array(21998).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9139)), 2088, 44);
} catch {}
let commandEncoder130 = device0.createCommandEncoder({});
let texture138 = device0.createTexture({size: {width: 128}, dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.STORAGE_BINDING});
let textureView126 = texture68.createView({baseMipLevel: 0});
try {
renderPassEncoder19.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup16, new Uint32Array(87), 76, 0);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer92);
} catch {}
let bindGroup45 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [{binding: 1, resource: sampler0}, {binding: 70, resource: {buffer: buffer70}}],
});
let textureView127 = texture112.createView({format: 'rgba16float', arrayLayerCount: 1});
try {
renderPassEncoder19.setBindGroup(3, bindGroup34, new Uint32Array(1049), 49, 0);
} catch {}
let pipeline18 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
let commandEncoder131 = device0.createCommandEncoder({});
try {
renderPassEncoder1.setVertexBuffer(0, buffer58, 0);
} catch {}
try {
renderBundleEncoder21.setBindGroup(2, bindGroup8);
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer90, 8, buffer24, 8, 8);
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
let bindGroup46 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: textureView8},
    {binding: 0, resource: textureView3},
    {binding: 3, resource: externalTexture0},
    {binding: 436, resource: externalTexture9},
    {binding: 144, resource: {buffer: buffer73}},
    {binding: 37, resource: {buffer: buffer68}},
    {binding: 82, resource: {buffer: buffer88}},
  ],
});
let texture139 = device0.createTexture({
  size: {width: 120, height: 120, depthOrArrayLayers: 49},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView128 = texture8.createView({aspect: 'all'});
try {
computePassEncoder20.setBindGroup(1, bindGroup25, new Uint32Array(4398), 75, 0);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer45, 8, 20);
} catch {}
let veryExplicitBindGroupLayout19 = device1.createBindGroupLayout({
  label: '\u{1f9ad}\u{1fe49}\ufbec\uffed\u0d5d',
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 41,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 51,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 99,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 317, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 445,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
  ],
});
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(84); };
} catch {}
document.body.prepend(img0);
let buffer125 = device1.createBuffer({label: '\u9188\u7a8f', size: 24, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder132 = device1.createCommandEncoder({});
let texture140 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 163},
  mipLevelCount: 4,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder26.setBindGroup(0, bindGroup43, [0]);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(4, buffer110, 8, 21);
} catch {}
let imageData23 = new ImageData(132, 56);
try {
renderBundleEncoder26.insertDebugMarker('\ub2a0');
} catch {}
let buffer126 = device0.createBuffer({
  label: '\u1a86\u{1ff38}\u{1ff6a}\u{1fca7}\u0ace\ufb50\u{1fafc}',
  size: 220,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder3.setBindGroup(3, bindGroup26);
} catch {}
let buffer127 = device1.createBuffer({
  size: 51,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
try {
computePassEncoder29.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder24.setBindGroup(3, bindGroup43, new Uint32Array(111), 26, 1);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(1, buffer105, 92);
} catch {}
let pipeline19 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute5', constants: {}}});
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(119); };
} catch {}
let commandEncoder133 = device1.createCommandEncoder({});
try {
renderBundleEncoder24.setBindGroup(0, bindGroup43, new Uint32Array(499), 12, 1);
} catch {}
try {
  await shaderModule5.getCompilationInfo();
} catch {}
try {
device1.queue.writeBuffer(buffer125, 0, new Uint32Array(2174).map((_, i) => i * 1), 43, 0);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup46, new Uint32Array(2558), 326, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer15, 'uint16', 6, 19);
} catch {}
try {
commandEncoder45.copyBufferToBuffer(buffer90, 40, buffer64, 4, 0);
} catch {}
let canvas2 = document.createElement('canvas');
let buffer128 = device0.createBuffer({size: 322, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder134 = device0.createCommandEncoder();
let computePassEncoder31 = commandEncoder48.beginComputePass();
let externalTexture15 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'});
try {
renderBundleEncoder5.setIndexBuffer(buffer12, 'uint32', 12, 24);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u71c2');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 12, y: 30 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
textureView21.label = '\u{1faa4}\u{1ff91}\u0af5\u{1fe65}\u762a\ueb2d\u06e5\u2293\u3a02\u97e3';
} catch {}
let textureView129 = texture23.createView({});
try {
computePassEncoder2.setBindGroup(0, bindGroup41, new Uint32Array(233), 39, 0);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(6, buffer73);
} catch {}
try {
computePassEncoder23.insertDebugMarker('\ub78f');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 15, y: 3, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise19;
} catch {}
document.body.prepend(canvas1);
let externalTexture16 = device0.importExternalTexture({source: videoFrame10});
try {
computePassEncoder31.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline7);
} catch {}
let buffer129 = device1.createBuffer({size: 396, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let texture141 = device1.createTexture({
  size: {width: 37, height: 5, depthOrArrayLayers: 1},
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder27 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8'});
try {
computePassEncoder30.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup43, [0]);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder135 = device0.createCommandEncoder({});
try {
renderPassEncoder14.setVertexBuffer(6, buffer53, 0, 17);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup18);
} catch {}
let buffer130 = device1.createBuffer({
  size: 468,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let commandEncoder136 = device1.createCommandEncoder({});
let texture142 = device1.createTexture({
  size: {width: 150, height: 20, depthOrArrayLayers: 25},
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView130 = texture133.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture123,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(74).fill(207), /* required buffer size: 74 */
{offset: 74}, {width: 75, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let pipeline20 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment6',
  constants: {},
  targets: [{
  format: 'rgba32sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'stencil8',
    stencilFront: {compare: 'less', failOp: 'keep', depthFailOp: 'increment-clamp', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'never', failOp: 'decrement-clamp', depthFailOp: 'replace'},
    stencilReadMask: 178624565,
    stencilWriteMask: 97406249,
    depthBias: -347398980,
    depthBiasSlopeScale: 671.3284385317326,
    depthBiasClamp: 0.0,
  },
  vertex: {
    module: shaderModule5,
    buffers: [
      {
        arrayStride: 192,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 48, shaderLocation: 9},
          {format: 'uint32', offset: 0, shaderLocation: 1},
          {format: 'float16x2', offset: 24, shaderLocation: 7},
          {format: 'sint16x2', offset: 12, shaderLocation: 4},
          {format: 'float32x3', offset: 32, shaderLocation: 8},
          {format: 'snorm8x4', offset: 32, shaderLocation: 0},
          {format: 'snorm16x2', offset: 12, shaderLocation: 6},
          {format: 'uint16x4', offset: 28, shaderLocation: 2},
          {format: 'uint16x4', offset: 40, shaderLocation: 12},
          {format: 'sint16x4', offset: 40, shaderLocation: 15},
          {format: 'uint8x2', offset: 30, shaderLocation: 5},
          {format: 'uint16x4', offset: 36, shaderLocation: 10},
          {format: 'uint16x4', offset: 40, shaderLocation: 13},
          {format: 'uint32x4', offset: 88, shaderLocation: 11},
          {format: 'uint32x4', offset: 8, shaderLocation: 3},
          {format: 'uint8x2', offset: 20, shaderLocation: 14},
        ],
      },
    ],
  },
});
let buffer131 = device0.createBuffer({size: 24, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
let textureView131 = texture126.createView({dimension: '2d-array'});
let texture143 = device0.createTexture({
  size: {width: 120, height: 120, depthOrArrayLayers: 107},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView132 = texture128.createView({mipLevelCount: 1});
try {
computePassEncoder9.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer17, 'uint32', 16, 6);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer49, 'uint16', 2, 9);
} catch {}
let pipeline21 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule6, constants: {}}});
let gpuCanvasContext4 = canvas2.getContext('webgpu');
let texture144 = device0.createTexture({
  size: [40],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder15.setBindGroup(1, bindGroup36);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer58, 0);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(6, buffer64, 0);
} catch {}
try {
commandEncoder69.clearBuffer(buffer11);
} catch {}
try {
computePassEncoder19.setBindGroup(2, bindGroup36);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup37, new Uint32Array(2446), 860, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer61, 'uint16', 0, 42);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
commandEncoder110.copyTextureToBuffer({
  texture: texture73,
  mipLevel: 0,
  origin: {x: 26, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2624 */
  offset: 2624,
  buffer: buffer94,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: imageData14,
  origin: { x: 6, y: 0 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 7, y: 13, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer132 = device0.createBuffer({size: 76, usage: GPUBufferUsage.MAP_READ});
try {
renderPassEncoder16.setBindGroup(3, bindGroup44);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup38, new Uint32Array(734), 38, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(3, buffer79, 12, 128);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup5);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup24, new Uint32Array(4419), 151, 0);
} catch {}
try {
buffer96.unmap();
} catch {}
let texture145 = gpuCanvasContext1.getCurrentTexture();
let renderBundleEncoder28 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', stencilReadOnly: true});
try {
renderBundleEncoder28.setBindGroup(3, bindGroup43, [0]);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline20);
} catch {}
let veryExplicitBindGroupLayout20 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let renderBundleEncoder29 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', depthReadOnly: true});
try {
computePassEncoder27.setPipeline(pipeline19);
} catch {}
let buffer133 = device1.createBuffer({size: 704, usage: GPUBufferUsage.UNIFORM});
let commandEncoder137 = device1.createCommandEncoder({});
try {
computePassEncoder26.setBindGroup(3, bindGroup43, [0]);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(0, buffer110, 0, 10);
} catch {}
try {
device1.queue.writeBuffer(buffer125, 4, new Uint32Array(12597).map((_, i) => i * 10), 476, 0);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture141,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(45).fill(182), /* required buffer size: 45 */
{offset: 45}, {width: 37, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise20 = device1.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'greater', failOp: 'decrement-clamp', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'greater', failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'replace'},
    stencilReadMask: 218804187,
    stencilWriteMask: 788463542,
    depthBias: -1614511068,
    depthBiasSlopeScale: 561.7592318266848,
  },
  vertex: {
    module: shaderModule5,
    constants: {},
    buffers: [
      {
        arrayStride: 8,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 11},
          {format: 'uint8x4', offset: 0, shaderLocation: 13},
          {format: 'sint32x2', offset: 0, shaderLocation: 15},
          {format: 'sint32', offset: 0, shaderLocation: 9},
          {format: 'uint32x2', offset: 0, shaderLocation: 10},
          {format: 'uint8x2', offset: 0, shaderLocation: 2},
          {format: 'uint16x2', offset: 0, shaderLocation: 5},
          {format: 'uint8x4', offset: 0, shaderLocation: 3},
          {format: 'sint32', offset: 0, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6},
          {format: 'uint32', offset: 0, shaderLocation: 1},
          {format: 'unorm8x4', offset: 0, shaderLocation: 8},
          {format: 'float16x2', offset: 0, shaderLocation: 0},
          {format: 'uint16x2', offset: 0, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'uint32x4', offset: 256, shaderLocation: 12},
          {format: 'float32x4', offset: 152, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', cullMode: 'front'},
});
let commandEncoder138 = device0.createCommandEncoder({});
try {
renderPassEncoder0.setBindGroup(0, bindGroup38);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let bindGroup47 = device0.createBindGroup({layout: autogeneratedBindGroupLayout3, entries: [{binding: 0, resource: {buffer: buffer98}}]});
try {
renderPassEncoder3.setIndexBuffer(buffer128, 'uint32', 40, 23);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 1,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(271).fill(223), /* required buffer size: 271 */
{offset: 271, bytesPerRow: 22}, {width: 1, height: 6, depthOrArrayLayers: 0});
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte240m', transfer: 'iec61966-2-1'} });
try {
renderPassEncoder15.setVertexBuffer(3, buffer131, 0, 0);
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(38); };
} catch {}
let commandEncoder139 = device0.createCommandEncoder({});
try {
renderBundleEncoder5.setVertexBuffer(0, buffer62, 4, 0);
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u8a3f');
} catch {}
let imageData24 = new ImageData(4, 4);
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'smpte170m'} });
let autogeneratedBindGroupLayout11 = pipeline20.getBindGroupLayout(0);
let bindGroup48 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 4, resource: textureView110},
    {binding: 44, resource: {buffer: buffer133, size: 35}},
    {binding: 0, resource: {buffer: buffer109}},
  ],
});
let commandEncoder140 = device1.createCommandEncoder({});
try {
computePassEncoder26.setBindGroup(3, bindGroup43, new Uint32Array(1337), 364, 1);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline17);
} catch {}
try {
commandEncoder128.clearBuffer(buffer105);
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout1]});
let commandEncoder141 = device0.createCommandEncoder({});
let texture146 = device0.createTexture({size: [30], dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_SRC});
let textureView133 = texture11.createView({});
try {
renderPassEncoder18.setBindGroup(2, bindGroup21, new Uint32Array(140), 33, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer53, 'uint16', 28, 18);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(4, buffer96);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 4, new BigInt64Array(625).map((_, i) => BigInt(i - 1)), 40, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup11, []);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(4, buffer50, 0, 3);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup11, new Uint32Array(514), 2, 0);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline7);
} catch {}
try {
commandEncoder73.copyBufferToBuffer(buffer12, 4, buffer48, 4, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: offscreenCanvas3,
  origin: { x: 58, y: 102 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 91, y: 12, z: 7},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 17, height: 7, depthOrArrayLayers: 0});
} catch {}
let buffer134 = device1.createBuffer({size: 308, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
try {
renderBundleEncoder26.setBindGroup(2, bindGroup43, new Uint32Array(134), 24, 1);
} catch {}
try {
buffer110.unmap();
} catch {}
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
  ],
});
let commandEncoder142 = device0.createCommandEncoder({});
try {
renderPassEncoder10.setPipeline(pipeline0);
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(9); };
} catch {}
try {
adapter1.label = '\u{1faf3}\u097f\u9dd8\u529f\u0389\u0232\u040c\u992b\u0252';
} catch {}
let textureView134 = texture78.createView({dimension: 'cube', baseArrayLayer: 1});
try {
renderPassEncoder19.setBindGroup(2, bindGroup8, new Uint32Array(2471), 991, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device1.label = '\u08fc\u4fe9';
} catch {}
let buffer135 = device1.createBuffer({size: 204, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let commandEncoder143 = device1.createCommandEncoder({});
let textureView135 = texture132.createView({dimension: '2d-array', aspect: 'all'});
try {
computePassEncoder27.setBindGroup(3, bindGroup43, new Uint32Array(506), 101, 1);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline20);
} catch {}
let pipeline22 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'not-equal', failOp: 'decrement-clamp', depthFailOp: 'increment-wrap', passOp: 'zero'},
    stencilBack: {compare: 'less-equal', failOp: 'increment-wrap', depthFailOp: 'invert', passOp: 'increment-wrap'},
    stencilReadMask: 459443339,
    stencilWriteMask: 73027427,
    depthBias: -2143524602,
    depthBiasSlopeScale: 828.8452979953711,
    depthBiasClamp: 850.1795103923619,
  },
  vertex: {
    module: shaderModule5,
    constants: {},
    buffers: [
      {
        arrayStride: 32,
        attributes: [
          {format: 'unorm8x2', offset: 2, shaderLocation: 0},
          {format: 'uint32', offset: 0, shaderLocation: 1},
          {format: 'uint32x2', offset: 0, shaderLocation: 11},
          {format: 'uint8x4', offset: 0, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 96,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 8, shaderLocation: 6},
          {format: 'uint16x2', offset: 16, shaderLocation: 14},
          {format: 'sint32', offset: 4, shaderLocation: 9},
          {format: 'uint32', offset: 0, shaderLocation: 12},
          {format: 'uint16x4', offset: 8, shaderLocation: 13},
          {format: 'sint8x2', offset: 0, shaderLocation: 4},
          {format: 'uint32x4', offset: 28, shaderLocation: 5},
          {format: 'unorm8x4', offset: 0, shaderLocation: 7},
          {format: 'sint32x3', offset: 68, shaderLocation: 15},
          {format: 'snorm8x4', offset: 12, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x2', offset: 104, shaderLocation: 3},
          {format: 'uint32x4', offset: 436, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front', unclippedDepth: true},
});
let imageData25 = new ImageData(48, 4);
let textureView136 = texture102.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5});
try {
computePassEncoder10.setBindGroup(1, bindGroup36);
} catch {}
try {
computePassEncoder12.setBindGroup(0, bindGroup45, new Uint32Array(329), 108, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup12, new Uint32Array(1954), 668, 0);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(2, buffer17, 36, 55);
} catch {}
document.body.append(canvas2);
let textureView137 = texture101.createView({});
try {
renderBundleEncoder14.setBindGroup(1, bindGroup12, new Uint32Array(957), 89, 0);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer61, 'uint32', 0, 18);
} catch {}
let commandEncoder144 = device1.createCommandEncoder({});
let textureView138 = texture131.createView({dimension: '2d', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 1});
document.body.prepend(canvas0);
let pipelineLayout9 = device0.createPipelineLayout({
  bindGroupLayouts: [autogeneratedBindGroupLayout10, veryExplicitBindGroupLayout8, veryExplicitBindGroupLayout10, autogeneratedBindGroupLayout9],
});
let buffer136 = device0.createBuffer({size: 612, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder145 = device0.createCommandEncoder({});
let textureView139 = texture83.createView({aspect: 'all'});
try {
computePassEncoder9.setBindGroup(3, bindGroup35, new Uint32Array(4314), 243, 0);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline5);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
let sampler24 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 89.31,
});
try {
device1.queue.writeBuffer(buffer127, 4, new DataView(new ArrayBuffer(75080)), 4517, 0);
} catch {}
await gc();
try {
computePassEncoder25.setBindGroup(1, bindGroup45);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(5, buffer58, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer59, 4, new Float32Array(2735).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.01215)), 628, 8);
} catch {}
let buffer137 = device0.createBuffer({size: 308, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let textureView140 = texture81.createView({baseArrayLayer: 0});
let sampler25 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 78.99});
try {
renderPassEncoder15.setBindGroup(2, bindGroup45, new Uint32Array(3909), 387, 0);
} catch {}
let textureView141 = texture133.createView({mipLevelCount: 1});
let externalTexture17 = device1.importExternalTexture({source: videoFrame8, colorSpace: 'srgb'});
let commandEncoder146 = device0.createCommandEncoder({label: '\u09b5\u{1fff7}\u{1fc44}\uc6c4\u0f89\u05a1\uadef'});
let textureView142 = texture69.createView({baseArrayLayer: 0});
try {
renderPassEncoder22.beginOcclusionQuery(110);
} catch {}
try {
renderBundleEncoder10.setBindGroup(0, bindGroup25);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer53, 'uint32', 4, 0);
} catch {}
document.body.prepend(canvas1);
try {
renderPassEncoder19.setBindGroup(3, bindGroup22, [0]);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup0, new Uint32Array(309), 73, 0);
} catch {}
try {
renderPassEncoder22.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer137, 8, new DataView(new Uint8Array(2411).map((_, i) => i).buffer), 430, 84);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(44_080).fill(59), /* required buffer size: 44_080 */
{offset: 82, bytesPerRow: 241, rowsPerImage: 87}, {width: 17, height: 9, depthOrArrayLayers: 3});
} catch {}
let pipeline23 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4}});
let veryExplicitBindGroupLayout22 = device1.createBindGroupLayout({
  entries: [
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let buffer138 = device1.createBuffer({size: 336, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE, mappedAtCreation: false});
let texture147 = device1.createTexture({
  size: [37, 5, 66],
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder32 = commandEncoder136.beginComputePass();
let renderBundleEncoder30 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', depthReadOnly: true});
try {
computePassEncoder32.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline22);
} catch {}
try {
device1.queue.writeBuffer(buffer124, 32, new Float32Array(1650).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.473)), 369, 4);
} catch {}
try {
  await promise21;
} catch {}
let commandEncoder147 = device1.createCommandEncoder({});
let textureView143 = texture133.createView({mipLevelCount: 1});
try {
computePassEncoder26.setBindGroup(0, bindGroup43, [0]);
} catch {}
try {
commandEncoder144.insertDebugMarker('\u{1f9c8}');
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(62); };
} catch {}
document.body.prepend(img0);
try {
computePassEncoder5.setBindGroup(3, bindGroup19, new Uint32Array(665), 190, 0);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(1, buffer62, 8, 12);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let buffer139 = device1.createBuffer({size: 628, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder148 = device1.createCommandEncoder({});
try {
computePassEncoder26.setBindGroup(2, bindGroup43, new Uint32Array(331), 185, 1);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder24.insertDebugMarker('\u0314');
} catch {}
let promise22 = device1.queue.onSubmittedWorkDone();
try {
computePassEncoder7.setBindGroup(3, bindGroup9, new Uint32Array(1532), 483, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup5, new Uint32Array(647), 11, 0);
} catch {}
try {
commandEncoder69.copyBufferToBuffer(buffer75, 100, buffer70, 68, 40);
} catch {}
try {
device0.queue.writeBuffer(buffer102, 8, new Uint16Array(1612).map((_, i) => i + 4), 361, 16);
} catch {}
document.body.append(img0);
let commandEncoder149 = device1.createCommandEncoder({});
let texture148 = device1.createTexture({
  size: [75, 10, 3],
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let texture149 = gpuCanvasContext2.getCurrentTexture();
let renderBundleEncoder31 = device1.createRenderBundleEncoder({
  colorFormats: ['rgba32sint'],
  depthStencilFormat: 'stencil8',
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder30.setBindGroup(1, bindGroup43, [0]);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer130, 'uint16', 70, 99);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder23.insertDebugMarker('\u026e');
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let bindGroup49 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 1, resource: externalTexture16},
    {binding: 64, resource: textureView17},
    {binding: 4, resource: textureView14},
    {binding: 630, resource: textureView16},
    {binding: 0, resource: {buffer: buffer52, offset: 0}},
  ],
});
let commandEncoder150 = device0.createCommandEncoder({});
let textureView144 = texture27.createView({label: '\u091f\u0498'});
try {
computePassEncoder13.setBindGroup(0, bindGroup15);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer60, 'uint16', 8, 4);
} catch {}
let pipeline24 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule2, targets: [{format: 'rg32uint'}]},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 0, shaderLocation: 7},
          {format: 'float32', offset: 12, shaderLocation: 12},
          {format: 'snorm8x4', offset: 0, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3},
          {format: 'uint8x2', offset: 6, shaderLocation: 5},
          {format: 'sint8x4', offset: 0, shaderLocation: 8},
          {format: 'float32', offset: 0, shaderLocation: 0},
          {format: 'sint8x2', offset: 4, shaderLocation: 9},
          {format: 'sint32x2', offset: 0, shaderLocation: 2},
          {format: 'sint32x2', offset: 0, shaderLocation: 10},
          {format: 'uint16x2', offset: 12, shaderLocation: 1},
          {format: 'sint16x2', offset: 4, shaderLocation: 11},
          {format: 'uint16x4', offset: 0, shaderLocation: 15},
          {format: 'snorm8x4', offset: 4, shaderLocation: 4},
          {format: 'snorm16x4', offset: 4, shaderLocation: 14},
        ],
      },
    ],
  },
});
let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 1, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 64,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 630,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let buffer140 = device0.createBuffer({size: 56, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let textureView145 = texture11.createView({dimension: '2d-array'});
try {
commandEncoder71.copyTextureToBuffer({
  texture: texture68,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2560 */
  offset: 2560,
  rowsPerImage: 1523,
  buffer: buffer94,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder116.pushDebugGroup('\u00e9');
} catch {}
await gc();
let buffer141 = device0.createBuffer({
  size: 319,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder2.setBindGroup(2, bindGroup47, []);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(3, buffer92);
} catch {}
try {
commandEncoder116.popDebugGroup();
} catch {}
try {
commandEncoder39.insertDebugMarker('\u{1f998}');
} catch {}
try {
  await promise22;
} catch {}
let imageData26 = new ImageData(28, 188);
try {
computePassEncoder24.setBindGroup(3, bindGroup21, new Uint32Array(42), 12, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup14, new Uint32Array(3315), 932, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(3, buffer17, 0);
} catch {}
try {
commandEncoder35.copyBufferToBuffer(buffer75, 160, buffer69, 28, 28);
} catch {}
let textureView146 = texture124.createView({});
let texture150 = device0.createTexture({
  size: [160, 120, 661],
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder5.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer137, 'uint32', 16, 34);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer55);
} catch {}
try {
renderBundleEncoder13.insertDebugMarker('\u32a6');
} catch {}
let pipeline25 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex1',
    buffers: [
      {
        arrayStride: 32,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 3},
          {format: 'uint8x2', offset: 0, shaderLocation: 5},
          {format: 'snorm16x4', offset: 0, shaderLocation: 13},
          {format: 'uint8x2', offset: 0, shaderLocation: 4},
          {format: 'sint32x3', offset: 4, shaderLocation: 14},
          {format: 'sint8x4', offset: 0, shaderLocation: 1},
          {format: 'unorm16x2', offset: 0, shaderLocation: 9},
          {format: 'snorm16x2', offset: 0, shaderLocation: 2},
          {format: 'sint32x2', offset: 0, shaderLocation: 11},
          {format: 'float32x3', offset: 0, shaderLocation: 6},
          {format: 'sint8x2', offset: 4, shaderLocation: 8},
          {format: 'sint32x3', offset: 0, shaderLocation: 0},
          {format: 'snorm8x2', offset: 2, shaderLocation: 10},
        ],
      },
      {arrayStride: 20, attributes: [{format: 'float32x2', offset: 0, shaderLocation: 12}]},
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', unclippedDepth: true},
});
document.body.prepend(img0);
let commandEncoder151 = device0.createCommandEncoder({label: '\u0765\ueed0\u{1fcd0}'});
let textureView147 = texture11.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
renderPassEncoder21.setIndexBuffer(buffer75, 'uint16', 106, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(2, buffer48, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer75, 'uint32', 60, 97);
} catch {}
try {
commandEncoder111.resolveQuerySet(querySet0, 20, 0, buffer96, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder152 = device1.createCommandEncoder();
try {
computePassEncoder30.setBindGroup(0, bindGroup48, new Uint32Array(165), 2, 1);
} catch {}
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'gamma22curve'} });
let buffer142 = device0.createBuffer({size: 264, usage: GPUBufferUsage.COPY_DST});
let texture151 = device0.createTexture({
  size: {width: 40},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder11.setBindGroup(3, bindGroup37, []);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture87,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 5},
  aspect: 'all',
}, new Uint8Array(83).fill(99), /* required buffer size: 83 */
{offset: 83, bytesPerRow: 56}, {width: 3, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder153 = device1.createCommandEncoder({});
let textureView148 = texture140.createView({aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 12, arrayLayerCount: 1});
try {
buffer138.unmap();
} catch {}
document.body.prepend(img0);
let textureView149 = texture119.createView({arrayLayerCount: 1});
try {
renderPassEncoder6.setIndexBuffer(buffer49, 'uint16', 70, 1);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(5, buffer62, 0, 2);
} catch {}
try {
commandEncoder118.insertDebugMarker('\u042b');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer59, 12, new Uint32Array(1171).map((_, i) => i * 1), 76, 4);
} catch {}
let renderPassEncoder23 = commandEncoder75.beginRenderPass({
  colorAttachments: [{
  view: textureView49,
  depthSlice: 56,
  clearValue: { r: 205.0, g: -498.8, b: -310.2, a: 259.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler26 = device0.createSampler({addressModeW: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 91.53, maxAnisotropy: 1});
try {
renderPassEncoder23.setIndexBuffer(buffer126, 'uint32', 28, 56);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline5);
} catch {}
let commandEncoder154 = device0.createCommandEncoder({});
try {
renderPassEncoder5.setBindGroup(3, bindGroup16, new Uint32Array(2313), 820, 0);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline1);
} catch {}
try {
commandEncoder135.copyBufferToBuffer(buffer67, 28, buffer102, 16, 8);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder155 = device0.createCommandEncoder({});
let texture152 = device0.createTexture({
  size: [30, 30, 48],
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder13.setIndexBuffer(buffer89, 'uint16', 16, 95);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline24);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup5);
} catch {}
try {
device0.queue.writeBuffer(buffer97, 12, new Uint32Array(4933).map((_, i) => i * 6), 81, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline26 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4}});
await gc();
let buffer143 = device0.createBuffer({size: 164, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder156 = device0.createCommandEncoder({});
try {
renderBundleEncoder0.setIndexBuffer(buffer24, 'uint16', 2, 6);
} catch {}
try {
buffer74.unmap();
} catch {}
try {
commandEncoder73.insertDebugMarker('\u14ef');
} catch {}
let renderBundleEncoder32 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8'});
try {
renderBundleEncoder30.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(1, buffer105, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer135, 4, new DataView(new Uint8Array(24406).map((_, i) => i).buffer), 9548, 48);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture141,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(9).fill(97), /* required buffer size: 9 */
{offset: 9}, {width: 37, height: 1, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout12 = pipeline19.getBindGroupLayout(0);
let bindGroup50 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout18,
  entries: [
    {binding: 51, resource: {buffer: buffer138, size: 260}},
    {binding: 317, resource: externalTexture13},
    {binding: 41, resource: {buffer: buffer139}},
    {binding: 445, resource: sampler23},
    {binding: 4, resource: textureView120},
    {binding: 99, resource: {buffer: buffer124, size: 92}},
  ],
});
let texture153 = device1.createTexture({
  size: {width: 37, height: 5, depthOrArrayLayers: 67},
  mipLevelCount: 3,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder33 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', stencilReadOnly: true});
let externalTexture18 = device1.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'});
try {
renderBundleEncoder24.setBindGroup(3, bindGroup50);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(2, buffer105, 0, 4);
} catch {}
try {
device1.queue.writeBuffer(buffer130, 80, new Uint32Array(3696).map((_, i) => i * 6), 235, 0);
} catch {}
let commandEncoder157 = device0.createCommandEncoder({});
try {
computePassEncoder31.setBindGroup(0, bindGroup20, new Uint32Array(1234), 7, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer126, 'uint32', 0, 11);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer64);
} catch {}
document.body.prepend(img0);
let buffer144 = device0.createBuffer({size: 32, usage: GPUBufferUsage.UNIFORM});
let commandEncoder158 = device0.createCommandEncoder({});
let texture154 = device0.createTexture({
  size: [20, 15, 82],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView150 = texture13.createView({mipLevelCount: 1});
try {
renderPassEncoder10.setVertexBuffer(3, buffer17, 56, 267);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup24, new Uint32Array(1998), 73, 0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(7, buffer92);
} catch {}
try {
commandEncoder50.copyTextureToBuffer({
  texture: texture116,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 320 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2680 */
  offset: 2680,
  bytesPerRow: 48640,
  buffer: buffer94,
}, {width: 40, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder73.resolveQuerySet(querySet2, 86, 4, buffer74, 0);
} catch {}
try {
computePassEncoder27.setBindGroup(0, bindGroup43, [0]);
} catch {}
await gc();
let bindGroup51 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout19,
  entries: [
    {binding: 41, resource: {buffer: buffer139}},
    {binding: 317, resource: externalTexture18},
    {binding: 99, resource: {buffer: buffer113, offset: 0}},
    {binding: 4, resource: textureView138},
    {binding: 445, resource: sampler23},
    {binding: 51, resource: {buffer: buffer138}},
  ],
});
let texture155 = device1.createTexture({
  size: {width: 75, height: 10, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView151 = texture118.createView({dimension: 'cube'});
let renderBundleEncoder34 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float'], sampleCount: 4, stencilReadOnly: true});
try {
gpuCanvasContext4.unconfigure();
} catch {}
let autogeneratedBindGroupLayout13 = pipeline9.getBindGroupLayout(0);
let commandEncoder159 = device0.createCommandEncoder();
try {
computePassEncoder17.setBindGroup(3, bindGroup15, new Uint32Array(2045), 53, 0);
} catch {}
try {
renderPassEncoder1.setScissorRect(7, 13, 0, 11);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer72, 'uint16', 26, 1);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer63, 0, 173);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder57.copyTextureToBuffer({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 26, y: 7, z: 6},
  aspect: 'all',
}, {
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2904 */
  offset: 2904,
  bytesPerRow: 22016,
  buffer: buffer94,
}, {width: 7, height: 3, depthOrArrayLayers: 0});
} catch {}
let img1 = await imageWithData(66, 21, '#10101010', '#20202020');
let textureView152 = texture141.createView({dimension: '2d-array', aspect: 'stencil-only'});
try {
computePassEncoder29.setBindGroup(1, bindGroup43, new Uint32Array(804), 52, 1);
} catch {}
try {
commandEncoder153.resolveQuerySet(querySet3, 108, 7, buffer130, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer127, 16, new DataView(new ArrayBuffer(10856)), 337, 0);
} catch {}
let textureView153 = texture133.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder33 = commandEncoder148.beginComputePass();
try {
computePassEncoder33.setPipeline(pipeline19);
} catch {}
try {
buffer124.unmap();
} catch {}
let veryExplicitBindGroupLayout24 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let texture156 = device1.createTexture({
  size: {width: 37, height: 5, depthOrArrayLayers: 82},
  mipLevelCount: 6,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder33.setBindGroup(2, bindGroup48, new Uint32Array(1580), 95, 1);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(0, buffer105, 0, 159);
} catch {}
let texture157 = device1.createTexture({
  size: [300, 40, 659],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderBundleEncoder31.setIndexBuffer(buffer130, 'uint16', 86, 38);
} catch {}
try {
device1.pushErrorScope('internal');
} catch {}
let imageData27 = new ImageData(32, 52);
let texture158 = device1.createTexture({
  size: {width: 75, height: 10, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView154 = texture142.createView({aspect: 'stencil-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 3});
let computePassEncoder34 = commandEncoder129.beginComputePass();
try {
computePassEncoder34.setPipeline(pipeline17);
} catch {}
let promise23 = device1.queue.onSubmittedWorkDone();
let buffer145 = device1.createBuffer({size: 72, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let textureView155 = texture153.createView({aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 12});
try {
computePassEncoder26.setBindGroup(2, bindGroup50, new Uint32Array(32), 5, 0);
} catch {}
let commandEncoder160 = device0.createCommandEncoder({});
let texture159 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 658},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder16.setBindGroup(0, bindGroup13, new Uint32Array(2837), 25, 0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer12, 'uint16', 0, 10);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(7, buffer104, 0, 10);
} catch {}
let bindGroup52 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 0, resource: {buffer: buffer124, size: 52}},
    {binding: 4, resource: textureView113},
    {binding: 44, resource: {buffer: buffer106}},
  ],
});
try {
renderBundleEncoder33.setIndexBuffer(buffer130, 'uint16', 26, 15);
} catch {}
try {
buffer130.unmap();
} catch {}
try {
  await promise23;
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires readonly_and_readwrite_storage_textures;

struct VertexInput35 {
  @location(12) location_12: vec2f,
  @location(2) location_2: vec2u,
  @location(3) @interpolate(flat) location_3: vec2h,
}

fn unconst_i32(v: i32) -> i32 { return v; }

fn unconst_f16(v: f16) -> f16 { return v; }

@group(0) @binding(0) var<storage, read_write> buffer146: array<array<array<array<T1, 7>, 1>, 64>>;

struct T2 {
  @size(36) f0: array<T1, 2>,
  f1: array<T1, 3>,
}

alias vec3b = vec3<bool>;

fn unconst_f32(v: f32) -> f32 { return v; }

var<private> vp6: i32 = i32(263456924);

fn unconst_u32(v: u32) -> u32 { return v; }

@id(28617) override override14: i32;

struct VertexOutput5 {
  @builtin(position) position: vec4f,
  @location(5) @interpolate(perspective, first) location_5: vec2f,
}

struct T1 {
  f0: vec2f,
}

struct T4 {
  @size(16) f0: atomic<i32>,
  @align(16) f1: array<T1>,
}

fn unconst_bool(v: bool) -> bool { return v; }

struct T5 {
  @size(8) f0: array<atomic<u32>, 1>,
}

struct T3 {
  f0: array<u32>,
}

struct T0 {
  @align(8) @size(8) f0: f16,
}

struct VertexInput36 {
  @location(1) location_1: vec2i,
}

var<private> vp5: vec4<bool> = vec4<bool>(false, true, false, false);

@group(0) @binding(10) var<storage, read_write> buffer147: T0;

@group(0) @binding(115) var st6: texture_storage_2d<r32float, read_write>;

struct ComputeInput8 {
  @builtin(num_workgroups) num_workgroups: vec3u,
  @builtin(workgroup_id) workgroup_id: vec3u,
}

/* zero global variables used */
@vertex
fn vertex6(@location(7) @interpolate(linear) location_7: vec2h, @builtin(vertex_index) vertex_index: u32, a2: VertexInput35, @location(4) @interpolate(linear) location_4: vec4f, a4: VertexInput36, @location(0) location_0: vec4i) -> VertexOutput5 {
  var out: VertexOutput5;
  loop {
  var vf78: bool = all(vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true)));
  var vf79: vec4<bool> = (bitcast<vec4h>(a2.location_2) == vec4h(log2(unconst_f16(3253.2))));
  let vf80: u32 = dot4U8Packed(bitcast<u32>((vec2i(unconst_i32(798764159), unconst_i32(239592757)) & vec2i(unconst_i32(135915264), unconst_i32(149124152))).g), unconst_u32(77937894));
  let vf81: vec4<bool> = (vec4h(unconst_f16(-879.2), unconst_f16(31179.5), unconst_f16(6961.1), unconst_f16(4345.9)) == vec4h(unconst_f16(4118.4), unconst_f16(6116.3), unconst_f16(17325.9), unconst_f16(2040.2)));
  break;
}
  out.position = out.location_5.grrg;
  out.position *= out.location_5.rrgg;
  out.position *= vec4f(out.location_5[unconst_u32(517983907)]);
  return out;
}

/* used global variables: buffer146, st6 */
@fragment
fn fragment8(@location(5) @interpolate(linear, first) location_5: vec2f, @builtin(sample_mask) sample_mask: u32, @builtin(position) position: vec4f, @builtin(sample_index) sample_index: u32) -> @location(200) vec2f {
  var out: vec2f;
  while bool((*&buffer146)[arrayLength(&(*&buffer146))][63][0][6].f0[0]) {
  buffer146[unconst_u32(637364316)][63][unconst_u32(2293829127)][unconst_u32(230366298)].f0 -= (*&buffer146)[unconst_u32(1328064750)][unconst_u32(817389686)][bitcast<u32>(buffer146[unconst_u32(90806945)][unconst_u32(603661139)][0][6].f0.g)][6].f0;
  let ptr88: ptr<storage, array<array<array<T1, 7>, 1>, 64>, read_write> = &(*&buffer146)[arrayLength(&(*&buffer146)) - 1];
  _ = buffer146;
}
  let ptr89: ptr<storage, T1, read_write> = &(*&buffer146)[unconst_u32(939510935)][unconst_u32(488071858)][0][unconst_u32(873509716)];
  let ptr90: ptr<storage, T1, read_write> = &(*&buffer146)[arrayLength(&(*&buffer146))][unconst_u32(8757383)][unconst_u32(456906809)][6];
  let ptr91: ptr<storage, array<array<array<T1, 7>, 1>, 64>, read_write> = &buffer146[arrayLength(&buffer146)];
  let ptr92: ptr<storage, array<array<T1, 7>, 1>, read_write> = &(*&buffer146)[arrayLength(&(*&buffer146))][bitcast<u32>((*&buffer146)[unconst_i32(-153511085)][63][0][6].f0.y)];
  for (var jj11=0u; jj11<66; jj11++) { buffer146[unconst_u32(33271488)][jj11][unconst_u32(251677959)][6].f0 = vec2f((*ptr91)[unconst_u32(982435446)][0][6].f0[unconst_u32(729126752)]); }
  switch i32(buffer146[unconst_u32(830269011)][63][unconst_u32(1693924736)][6].f0[1]) { 
  case 136228209, default, 154381337 {
  let ptr93: ptr<storage, vec2f, read_write> = &buffer146[arrayLength(&buffer146)][63][unconst_u32(553817573)][unconst_u32(488349136)].f0;
  textureStore(st6, vec2i(unconst_i32(186890820), unconst_i32(53048225)), vec4f((*&buffer146)[arrayLength(&(*&buffer146))][63][0][6].f0.rggg));
  var vf82: f32 = position[pack2x16float((*&buffer146)[unconst_u32(729637878)][63][0][6].f0)];
  let vf83: ptr<storage, array<array<array<array<T1, 7>, 1>, 64>>, read_write> = &buffer146;
  break;
  _ = st6;
  _ = buffer146;
}
  }
  out = buffer146[arrayLength(&buffer146)][63][unconst_u32(289738343)][6].f0;
  let ptr94: ptr<storage, T1, read_write> = &(*&buffer146)[unconst_u32(774810208)][unconst_u32(188442068)][0][6];
  return out;
  _ = st6;
  _ = buffer146;
}

/* used global variables: buffer146, buffer147 */
@compute @workgroup_size(2, 1, 1)
fn compute7(a0: ComputeInput8) {
  while bool(buffer146[arrayLength(&buffer146)][63][unconst_u32(361598832)][6].f0[unconst_u32(65775927)]) {
  let vf84: f32 = buffer146[arrayLength(&buffer146)][63][0][6].f0[unconst_u32(38442265)];
  buffer147.f0 = f16(buffer146[unconst_u32(576884345)][unconst_u32(33176916)][unconst_u32(74772985)][6].f0[0]);
  _ = buffer146;
  _ = buffer147;
}
  let ptr95: ptr<storage, T1, read_write> = &buffer146[arrayLength(&buffer146)][unconst_u32(271165464)][0][unconst_u32(703695502)];
  _ = buffer146;
  _ = buffer147;
}`,
});
let buffer148 = device0.createBuffer({size: 148, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let textureView156 = texture106.createView({dimension: '2d-array'});
try {
commandEncoder57.copyBufferToBuffer(buffer103, 32, buffer48, 8, 4);
} catch {}
try {
computePassEncoder19.insertDebugMarker('\u2f1f');
} catch {}
let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 70,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let buffer149 = device0.createBuffer({label: '\u07ba\u{1fdea}\u{1ff84}\uf1c9\u0d85\u8ef9', size: 48, usage: GPUBufferUsage.INDEX});
let commandEncoder161 = device0.createCommandEncoder({});
try {
renderPassEncoder20.setVertexBuffer(3, buffer75, 216, 13);
} catch {}
try {
buffer99.unmap();
} catch {}
try {
commandEncoder78.copyTextureToTexture({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 11},
  aspect: 'all',
},
{
  texture: texture53,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer102, 0, new Float16Array(7006).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.036)), 891, 0);
} catch {}
let promise24 = device0.queue.onSubmittedWorkDone();
try {
  await promise24;
} catch {}
await gc();
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpteSt4281', transfer: 'bt709'} });
let bindGroup53 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 82, resource: {buffer: buffer0}},
    {binding: 436, resource: externalTexture1},
    {binding: 3, resource: externalTexture2},
    {binding: 37, resource: {buffer: buffer88, size: 132}},
    {binding: 0, resource: textureView3},
    {binding: 1, resource: textureView1},
    {binding: 144, resource: {buffer: buffer70}},
  ],
});
try {
renderPassEncoder3.setIndexBuffer(buffer75, 'uint32', 4, 35);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer64, 0, 3);
} catch {}
try {
commandEncoder56.resolveQuerySet(querySet1, 5, 1, buffer96, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer93, 44, new Float32Array(4330).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.159)), 946, 0);
} catch {}
let sampler27 = device1.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 74.45,
  compare: 'less',
});
let texture160 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 1},
  sampleCount: 4,
  dimension: '2d',
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView157 = texture135.createView({dimension: '2d', format: 'stencil8', baseArrayLayer: 1});
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} });
let bindGroup54 = device1.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 0, resource: {buffer: buffer124, size: 64}}, {binding: 4, resource: textureView113}],
});
let commandEncoder162 = device1.createCommandEncoder({});
let texture161 = device1.createTexture({
  size: {width: 150, height: 20, depthOrArrayLayers: 329},
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'bt709'} });
try {
computePassEncoder22.setBindGroup(2, bindGroup18, new Uint32Array(2514), 30, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer14, 'uint32', 0, 9);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let shaderModule8 = device1.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

struct T2 {
  @align(64) f0: array<array<f16, 1>>,
}

var<private> vp7: f16 = f16(29812.9);

struct FragmentInput17 {
  @location(10) @interpolate(flat, centroid) location_10: i32,
}

@group(0) @binding(0) var<storage, read_write> buffer150: array<array<array<array<array<f16, 1>, 3>, 1>, 5>>;

struct VertexInput40 {
  @builtin(instance_index) instance_index: u32,
}

fn unconst_u32(v: u32) -> u32 { return v; }

struct VertexInput38 {
  @location(14) location_14: vec2i,
  @location(3) @interpolate(perspective, either) location_3: vec2f,
  @location(1) location_1: i32,
}

struct FragmentInput16 {
  @location(15) @interpolate(perspective, centroid) location_15: vec4h,
  @location(0) @interpolate(perspective, first) location_0: vec4h,
}

struct VertexInput37 {
  @location(9) @interpolate(perspective, either) location_9: vec4f,
  @location(12) @interpolate(flat, sample) location_12: vec2i,
  @location(15) location_15: vec2i,
  @location(0) location_0: f16,
  @location(11) @interpolate(flat) location_11: f32,
  @location(13) @interpolate(perspective, sample) location_13: f16,
  @location(7) @interpolate(flat, sample) location_7: vec4f,
}

@id(44468) override override16: bool;

struct FragmentOutput7 {
  @location(0) @interpolate(linear, sample) location_0: vec4f,
}

struct VertexOutput6 {
  @location(0) @interpolate(perspective, first) location_0: vec4h,
  @location(3) location_3: vec2f,
  @location(5) location_5: i32,
  @location(12) @interpolate(flat, either) location_12: vec2f,
  @invariant @builtin(position) position: vec4f,
  @location(10) @interpolate(flat, centroid) location_10: i32,
  @location(1) @interpolate(flat, centroid) location_1: vec4i,
  @location(11) @interpolate(linear, either) location_11: f16,
  @location(15) @interpolate(perspective, centroid) location_15: vec4h,
  @location(14) @interpolate(flat, either) location_14: u32,
}

var<private> vp8: array<vec4<bool>, 15> = array<vec4<bool>, 15>(vec4<bool>(false, false, false, false), vec4<bool>(true, true, false, false), vec4<bool>(false, false, true, false), vec4<bool>(true, true, false, true), vec4<bool>(true, true, true, false), vec4<bool>(false, true, false, false), vec4<bool>(true, false, false, false), vec4<bool>(false, true, false, true), vec4<bool>(true, false, false, true), vec4<bool>(true, false, true, true), vec4<bool>(true, true, true, true), vec4<bool>(true, false, false, false), vec4<bool>(true, false, false, false), vec4<bool>(false, false, false, true), vec4<bool>(true, false, false, false));

fn unconst_i32(v: i32) -> i32 { return v; }

fn unconst_f16(v: f16) -> f16 { return v; }

override override17: i32;

var<workgroup> vw11: atomic<u32>;

@id(38409) override override15: u32;

@group(0) @binding(44) var<uniform> buffer151: FragmentOutput7;

fn unconst_bool(v: bool) -> bool { return v; }

struct T1 {
  @size(30) f0: atomic<u32>,
}

struct T0 {
  @size(30) f0: atomic<u32>,
}

override override18: i32 = 157480045;

fn unconst_f32(v: f32) -> f32 { return v; }

struct VertexInput39 {
  @location(10) location_10: f16,
  @location(5) location_5: vec4u,
}

/* zero global variables used */
@vertex
fn vertex7(@location(2) @interpolate(linear) location_2: f16, @location(6) @interpolate(flat, center) location_6: vec2u, @location(4) location_4: i32, a3: VertexInput37, a4: VertexInput38, a5: VertexInput39, @location(8) @interpolate(perspective, center) location_8: vec4f, a7: VertexInput40, @builtin(vertex_index) vertex_index: u32) -> VertexOutput6 {
  var out: VertexOutput6;
  out.location_12 -= vec2f(f32(location_4));
  out.location_1 *= vec4i(dot(vec4i(unconst_i32(69143797), unconst_i32(497704541), unconst_i32(6454276), unconst_i32(725583302)), vec4i(unconst_i32(-22361386), unconst_i32(212123021), unconst_i32(66532497), unconst_i32(502115614))));
  let vf85: vec4u = a5.location_5;
  let vf86: vec2h = faceForward(vec2h(unconst_f16(873.3), unconst_f16(27823.5)), vec2h(unconst_f16(14027.4), unconst_f16(12580.0)), vec2h(unconst_f16(4826.4), unconst_f16(2445.1)));
  let vf87: i32 = override18;
  let ptr96: ptr<function, i32> = &out.location_5;
  out.position = unpack4x8snorm(vf85[a5.location_5[2]]);
  var vf88: i32 = a3.location_15[unconst_u32(956158459)];
  var vf89: VertexInput39 = a5;
  switch vec4u(vp8[14]).b { 
  case default, 1388094151: {
  let ptr97: ptr<function, i32> = &out.location_10;
  let ptr98: ptr<function, i32> = &out.location_10;
}
  }
  let vf90: i32 = vf87;
  out.position = vec4f(vp8[14].argr);
  return out;
  _ = override18;
}

/* used global variables: buffer150, buffer151 */
@fragment
fn fragment9(@location(1) @interpolate(flat) location_1: vec4i, a1: FragmentInput16, @location(12) @interpolate(linear) location_12: vec2f, a3: FragmentInput17, @location(5) location_5: i32, @location(3) @interpolate(linear, sample) location_3: vec2f, @location(11) @interpolate(linear) location_11: f16, @location(14) location_14: u32) -> FragmentOutput7 {
  var out: FragmentOutput7;
  let ptr99: ptr<storage, f16, read_write> = &(*&buffer150)[arrayLength(&(*&buffer150))][4][u32(out.location_0[unconst_u32(1015786147)])][2][unconst_u32(683341988)];
  let ptr100: ptr<storage, array<f16, 1>, read_write> = &buffer150[u32(buffer150[arrayLength(&buffer150)][unconst_u32(12143892)][0][2][0])][4][unconst_u32(387423006)][unconst_u32(255545862)];
  vp8[unconst_u32(563680923)] = vec4<bool>(bool((*&buffer150)[arrayLength(&(*&buffer150))][4][unconst_u32(127956160)][2][0]));
  out.location_0 = vec4f(f32((*&buffer150)[unconst_u32(1555458754)][4][unconst_u32(7387297)][2][0]));
  out.location_0 += vec4f(f32(buffer150[unconst_u32(437863326)][unconst_u32(1001854011)][unconst_u32(269997617)][unconst_u32(167599512)][0]));
  var vf91: f32 = buffer151.location_0[unconst_u32(536695842)];
  let ptr101: ptr<storage, array<f16, 1>, read_write> = &(*&buffer150)[arrayLength(&(*&buffer150))][4][unconst_u32(644840059)][2];
  vf91 *= f32((*&buffer150)[unconst_u32(2202504583)][unconst_u32(420463729)][0][2][0]);
  return out;
  _ = buffer151;
  _ = buffer150;
}`,
});
let commandEncoder163 = device1.createCommandEncoder({});
let textureView158 = texture118.createView({dimension: '2d', baseArrayLayer: 3});
try {
renderBundleEncoder28.setBindGroup(0, bindGroup51);
} catch {}
try {
buffer138.unmap();
} catch {}
let bindGroup55 = device1.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 4, resource: textureView151}, {binding: 0, resource: {buffer: buffer135}}],
});
let commandEncoder164 = device1.createCommandEncoder({});
let computePassEncoder35 = commandEncoder132.beginComputePass();
try {
commandEncoder133.copyTextureToTexture({
  texture: texture156,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture130,
  mipLevel: 1,
  origin: {x: 39, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder165 = device0.createCommandEncoder();
let texture162 = device0.createTexture({
  size: [20, 15, 82],
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
buffer52.unmap();
} catch {}
try {
commandEncoder50.copyBufferToTexture({
  /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 568 */
  offset: 568,
  bytesPerRow: 3072,
  rowsPerImage: 196,
  buffer: buffer136,
}, {
  texture: texture124,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer101, 24, new DataView(new ArrayBuffer(25400)), 1452, 0);
} catch {}
let promise25 = device0.queue.onSubmittedWorkDone();
try {
globalThis.someLabel = renderPassEncoder8.label;
} catch {}
let autogeneratedBindGroupLayout14 = pipeline25.getBindGroupLayout(1);
let buffer152 = device0.createBuffer({size: 540, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX, mappedAtCreation: false});
let textureView159 = texture162.createView({format: 'rg32sint', baseArrayLayer: 0});
try {
renderPassEncoder14.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(6, buffer45, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer102, 8, new Float32Array(31879).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.707)), 608, 4);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let buffer153 = device0.createBuffer({size: 220, usage: GPUBufferUsage.COPY_DST});
let texture163 = device0.createTexture({
  size: [60, 60, 1],
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder8.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(3, undefined, 0, 18_778_771);
} catch {}
try {
buffer149.unmap();
} catch {}
let bindGroup56 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [{binding: 1, resource: sampler0}, {binding: 70, resource: {buffer: buffer70}}],
});
let buffer154 = device0.createBuffer({size: 96, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder166 = device0.createCommandEncoder({});
let texture164 = device0.createTexture({
  size: {width: 40, height: 30, depthOrArrayLayers: 165},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder18.beginOcclusionQuery(136);
} catch {}
try {
renderPassEncoder18.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder0.insertDebugMarker('\u{1fb90}');
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder167 = device0.createCommandEncoder();
let texture165 = device0.createTexture({
  size: [128, 128, 100],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture166 = device0.createTexture({
  size: {width: 128},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder24 = commandEncoder73.beginRenderPass({
  colorAttachments: [{
  view: textureView25,
  depthSlice: 26,
  clearValue: { r: -311.3, g: 656.1, b: 88.58, a: 801.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder12.setBindGroup(2, bindGroup41);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer12, 'uint32', 8, 41);
} catch {}
try {
commandEncoder86.copyBufferToBuffer(buffer102, 20, buffer141, 76, 0);
} catch {}
let commandEncoder168 = device0.createCommandEncoder({});
let texture167 = device0.createTexture({
  size: {width: 30, height: 30, depthOrArrayLayers: 12},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture168 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1, depthReadOnly: true});
let externalTexture19 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder4.setBindGroup(1, bindGroup13, new Uint32Array(99), 2, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup15, new Uint32Array(538), 70, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(6, buffer140);
} catch {}
try {
device0.queue.writeBuffer(buffer148, 12, new DataView(new ArrayBuffer(53740)), 2938, 0);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let buffer155 = device1.createBuffer({size: 1009, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView160 = texture140.createView({dimension: '2d', aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 23});
try {
computePassEncoder35.setPipeline(pipeline19);
} catch {}
let imageData28 = new ImageData(4, 16);
try {
renderBundleEncoder23.setIndexBuffer(buffer145, 'uint32', 4, 3);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(7, buffer110, 0);
} catch {}
try {
buffer105.unmap();
} catch {}
document.body.prepend(canvas0);
let textureView161 = texture165.createView({});
try {
computePassEncoder9.setBindGroup(0, bindGroup29, new Uint32Array(3393), 657, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup32);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer57, 'uint16', 2, 21);
} catch {}
try {
buffer49.unmap();
} catch {}
try {
commandEncoder141.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 240 */
  offset: 240,
  bytesPerRow: 25856,
  buffer: buffer136,
}, {
  texture: texture113,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer141, 16, new Uint32Array(55).map((_, i) => i * 1), 9, 0);
} catch {}
offscreenCanvas2.height = 1060;
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} });
let texture169 = device0.createTexture({
  size: {width: 30, height: 30, depthOrArrayLayers: 4},
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder19.setVertexBuffer(1, buffer92);
} catch {}
try {
buffer67.unmap();
} catch {}
let textureView162 = texture133.createView({aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1});
try {
commandEncoder128.copyTextureToTexture({
  texture: texture130,
  mipLevel: 0,
  origin: {x: 22, y: 6, z: 0},
  aspect: 'all',
},
{
  texture: texture157,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 48},
  aspect: 'all',
},
{width: 20, height: 2, depthOrArrayLayers: 8});
} catch {}
try {
device1.queue.writeBuffer(buffer138, 20, new DataView(new Uint8Array(10351).map((_, i) => i).buffer), 1231, 44);
} catch {}
let pipeline27 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute5'}});
let buffer156 = device0.createBuffer({size: 148, usage: GPUBufferUsage.INDEX, mappedAtCreation: false});
let textureView163 = texture83.createView({});
let externalTexture20 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'});
try {
renderPassEncoder14.beginOcclusionQuery(127);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer102, 'uint16', 22, 0);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer89, 'uint32', 36, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 12, y: 7, z: 0},
  aspect: 'all',
}, new Uint8Array(18).fill(168), /* required buffer size: 18 */
{offset: 18, bytesPerRow: 73}, {width: 9, height: 17, depthOrArrayLayers: 0});
} catch {}
let buffer157 = device1.createBuffer({size: 80, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let sampler28 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 30.45,
  compare: 'equal',
});
try {
computePassEncoder26.setBindGroup(3, bindGroup52, [0]);
} catch {}
try {
device1.queue.writeBuffer(buffer127, 8, new DataView(new ArrayBuffer(6904)), 141, 8);
} catch {}
let pipeline28 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute5', constants: {}}});
try {
  await promise25;
} catch {}
let texture170 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup53);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup35);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer61, 'uint32', 0, 55);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup35, []);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer76, 'uint16', 4, 5);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 160, height: 120, depthOrArrayLayers: 661}
*/
{
  source: imageData12,
  origin: { x: 10, y: 4 },
  flipY: false,
}, {
  texture: texture150,
  mipLevel: 0,
  origin: {x: 0, y: 19, z: 109},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline29 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, constants: {}}});
let texture171 = device0.createTexture({
  size: {width: 60, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView164 = texture21.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder21.setBindGroup(3, bindGroup19, new Uint32Array(435), 66, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer14, 'uint16', 8, 2);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup3, []);
} catch {}
try {
commandEncoder156.copyTextureToTexture({
  texture: texture111,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture167,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline30 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
let bindGroup57 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout19,
  entries: [
    {binding: 41, resource: {buffer: buffer155, size: 652}},
    {binding: 99, resource: {buffer: buffer138}},
    {binding: 51, resource: {buffer: buffer138}},
    {binding: 445, resource: sampler28},
    {binding: 4, resource: textureView120},
    {binding: 317, resource: externalTexture13},
  ],
});
try {
computePassEncoder30.setBindGroup(0, bindGroup50);
} catch {}
try {
device1.queue.writeBuffer(buffer135, 24, new Float64Array(10599).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/10597)), 76, 12);
} catch {}
let pipeline31 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}});
let commandEncoder169 = device0.createCommandEncoder({});
let textureView165 = texture38.createView({dimension: 'cube', baseArrayLayer: 2});
let externalTexture21 = device0.importExternalTexture({source: videoFrame7});
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(5, buffer140, 4, 7);
} catch {}
let texture172 = device0.createTexture({
  size: [128],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler29 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 94.60,
});
let externalTexture22 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder15.setBindGroup(2, bindGroup0, new Uint32Array(2132), 471, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer126, 'uint32', 32, 19);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(4, buffer141);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer73, 8, 6);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer152, 'uint32', 100, 58);
} catch {}
let commandEncoder170 = device1.createCommandEncoder({});
try {
device1.queue.copyExternalImageToTexture(/*
{width: 37, height: 5, depthOrArrayLayers: 82}
*/
{
  source: imageData4,
  origin: { x: 0, y: 15 },
  flipY: false,
}, {
  texture: texture161,
  mipLevel: 2,
  origin: {x: 2, y: 3, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView166 = texture157.createView({baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder33.setBindGroup(1, bindGroup48, [0]);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let autogeneratedBindGroupLayout15 = pipeline10.getBindGroupLayout(0);
let commandEncoder171 = device0.createCommandEncoder({});
let sampler30 = device0.createSampler({addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMinClamp: 80.90, lodMaxClamp: 92.74});
try {
computePassEncoder3.setBindGroup(1, bindGroup44, []);
} catch {}
try {
renderBundleEncoder22.setBindGroup(1, bindGroup1);
} catch {}
let pipeline32 = device0.createRenderPipeline({
  label: '\u{1f84f}\u3b62\u0991\u394b\u{1f725}\u9cee',
  layout: 'auto',
  fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rg32uint', writeMask: 0}]},
  vertex: {
    module: shaderModule6,
    constants: {override12: 1},
    buffers: [
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 0, shaderLocation: 9},
          {format: 'snorm8x2', offset: 0, shaderLocation: 8},
          {format: 'sint32x2', offset: 0, shaderLocation: 4},
          {format: 'unorm8x4', offset: 0, shaderLocation: 15},
          {format: 'uint32x2', offset: 0, shaderLocation: 10},
          {format: 'unorm16x2', offset: 0, shaderLocation: 6},
          {format: 'snorm16x2', offset: 0, shaderLocation: 14},
          {format: 'unorm16x4', offset: 0, shaderLocation: 1},
          {format: 'uint32x3', offset: 0, shaderLocation: 3},
          {format: 'uint8x4', offset: 0, shaderLocation: 5},
          {format: 'snorm16x2', offset: 0, shaderLocation: 11},
          {format: 'sint16x4', offset: 4, shaderLocation: 7},
          {format: 'sint32x4', offset: 0, shaderLocation: 2},
          {format: 'sint8x2', offset: 4, shaderLocation: 12},
          {format: 'sint16x2', offset: 0, shaderLocation: 0},
          {format: 'sint32x4', offset: 0, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'front', unclippedDepth: true},
});
let commandEncoder172 = device0.createCommandEncoder({});
let texture173 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
await gc();
let buffer158 = device1.createBuffer({size: 212, usage: GPUBufferUsage.STORAGE, mappedAtCreation: false});
let texture174 = device1.createTexture({
  size: {width: 150},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView167 = texture153.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let sampler31 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 61.07,
  maxAnisotropy: 16,
});
let externalTexture23 = device1.importExternalTexture({source: videoFrame9});
let textureView168 = texture174.createView({});
let renderPassEncoder25 = commandEncoder170.beginRenderPass({
  colorAttachments: [{
  view: textureView166,
  depthSlice: 138,
  clearValue: { r: -895.9, g: -446.5, b: -936.0, a: -885.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  depthStencilAttachment: {
    view: textureView135,
    depthClearValue: -9.983658358191516,
    depthReadOnly: true,
    stencilLoadOp: 'load',
    stencilStoreOp: 'store',
  },
  maxDrawCount: 376286741,
});
try {
renderBundleEncoder34.setVertexBuffer(2, buffer157);
} catch {}
try {
device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); });
} catch {}
try {
buffer129.unmap();
} catch {}
try {
gpuCanvasContext4.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'hlg'} });
let bindGroup58 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout18,
  entries: [
    {binding: 445, resource: sampler27},
    {binding: 4, resource: textureView119},
    {binding: 51, resource: {buffer: buffer139}},
    {binding: 317, resource: externalTexture17},
    {binding: 41, resource: {buffer: buffer155, size: 472}},
    {binding: 99, resource: {buffer: buffer124, size: 92}},
  ],
});
let buffer159 = device1.createBuffer({size: 488, usage: GPUBufferUsage.INDEX});
let texture175 = device1.createTexture({
  size: {width: 150, height: 20, depthOrArrayLayers: 9},
  mipLevelCount: 4,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView169 = texture157.createView({format: 'rgba32sint', mipLevelCount: 1, arrayLayerCount: 1});
let externalTexture24 = device1.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
renderPassEncoder25.setBindGroup(3, bindGroup51, new Uint32Array(2533), 106, 0);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(0, buffer110, 8, 15);
} catch {}
let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt709', transfer: 'smpte240m'} });
let bindGroup59 = device1.createBindGroup({layout: autogeneratedBindGroupLayout12, entries: [{binding: 4, resource: textureView113}]});
let commandEncoder173 = device1.createCommandEncoder({});
let texture176 = device1.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 39},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView170 = texture131.createView({baseArrayLayer: 4, arrayLayerCount: 10});
try {
renderBundleEncoder32.setBindGroup(1, bindGroup55);
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup50, new Uint32Array(1215), 422, 0);
} catch {}
let commandEncoder174 = device1.createCommandEncoder();
let textureView171 = texture131.createView({dimension: '2d', format: 'rgba16float', mipLevelCount: 1, baseArrayLayer: 6});
let computePassEncoder36 = commandEncoder144.beginComputePass();
try {
renderBundleEncoder31.setIndexBuffer(buffer159, 'uint32', 188, 66);
} catch {}
try {
buffer113.unmap();
} catch {}
let pipeline33 = await promise20;
let buffer160 = device1.createBuffer({size: 72, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let texture177 = device1.createTexture({
  size: [37, 5, 82],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder33.setBindGroup(1, bindGroup43, [0]);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup52, new Uint32Array(697), 222, 1);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline22);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'unspecified', transfer: 'smpte240m'} });
let buffer161 = device0.createBuffer({
  size: 6368,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture178 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 84},
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup16, new Uint32Array(880), 62, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
let videoFrame23 = videoFrame3.clone();
let buffer162 = device1.createBuffer({size: 16, usage: GPUBufferUsage.INDEX});
let texture179 = device1.createTexture({size: [300], dimension: '1d', format: 'rgba32sint', usage: GPUTextureUsage.COPY_DST});
let textureView172 = texture135.createView({label: '\u{1fa52}\uefd1\ud868', dimension: '2d', baseArrayLayer: 1});
let computePassEncoder37 = commandEncoder143.beginComputePass();
try {
computePassEncoder36.setPipeline(pipeline31);
} catch {}
let texture180 = device1.createTexture({
  size: [300, 40, 33],
  dimension: '2d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder37.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline33);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(0, buffer110, 0, 4);
} catch {}
let videoFrame24 = new VideoFrame(videoFrame23, {timestamp: 0});
let buffer163 = device0.createBuffer({size: 152, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let commandEncoder175 = device0.createCommandEncoder({});
let textureView173 = texture81.createView({format: 'rg32uint'});
try {
computePassEncoder5.setBindGroup(3, bindGroup16);
} catch {}
let bindGroup60 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [{binding: 1, resource: sampler5}, {binding: 70, resource: {buffer: buffer99, offset: 0, size: 294}}],
});
let commandEncoder176 = device0.createCommandEncoder({});
try {
buffer45.unmap();
} catch {}
try {
commandEncoder76.pushDebugGroup('\ub84a');
} catch {}
try {
device0.queue.writeBuffer(buffer65, 32, new Float32Array(59229).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.148)), 455, 8);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(27); };
} catch {}
let texture181 = device1.createTexture({
  size: {width: 37, height: 5, depthOrArrayLayers: 82},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView174 = texture141.createView({dimension: '2d-array'});
try {
renderPassEncoder25.setBindGroup(2, bindGroup48, [0]);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(1, buffer110, 0, 6);
} catch {}
try {
commandEncoder174.copyBufferToTexture({
  /* bytesInLastRow: 37 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 88 */
  offset: 88,
  bytesPerRow: 64000,
  buffer: buffer129,
}, {
  texture: texture141,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {width: 37, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device1.queue.writeBuffer(buffer124, 8, new Float16Array(32762).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.250)), 6791, 8);
} catch {}
let imageData29 = new ImageData(16, 16);
let commandEncoder177 = device0.createCommandEncoder({});
let textureView175 = texture58.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 8, arrayLayerCount: 6});
try {
renderPassEncoder2.setIndexBuffer(buffer14, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup23, []);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(0, buffer79, 0, 0);
} catch {}
try {
commandEncoder76.popDebugGroup();
} catch {}
let commandEncoder178 = device1.createCommandEncoder({});
let texture182 = device1.createTexture({
  size: [150, 20, 20],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture183 = device1.createTexture({
  size: [37, 5, 1],
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView176 = texture155.createView({dimension: '2d-array'});
let renderBundleEncoder36 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder26.setBindGroup(0, bindGroup48, [0]);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(0, buffer110);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup51);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(3, buffer105, 0, 37);
} catch {}
try {
commandEncoder147.copyTextureToTexture({
  texture: texture156,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 6},
  aspect: 'all',
},
{
  texture: texture157,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 6},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 11});
} catch {}
try {
commandEncoder133.resolveQuerySet(querySet3, 56, 0, buffer129, 0);
} catch {}
document.body.prepend(img1);
let bindGroup61 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 186, resource: {buffer: buffer98}},
    {binding: 7, resource: {buffer: buffer161}},
    {binding: 5, resource: {buffer: buffer98}},
  ],
});
let textureView177 = texture164.createView({});
try {
computePassEncoder23.setBindGroup(1, bindGroup60);
} catch {}
try {
computePassEncoder3.setBindGroup(3, bindGroup2, new Uint32Array(1001), 129, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: videoFrame24,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 6, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(33); };
} catch {}
let texture184 = device0.createTexture({
  size: {width: 15},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler32 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 88.09,
  compare: 'always',
  maxAnisotropy: 4,
});
try {
gpuCanvasContext2.unconfigure();
} catch {}
let commandEncoder179 = device0.createCommandEncoder({});
let textureView178 = texture184.createView({baseArrayLayer: 0});
let texture185 = device0.createTexture({
  size: {width: 120, height: 120, depthOrArrayLayers: 49},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler33 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge', minFilter: 'nearest'});
try {
device0.queue.writeBuffer(buffer102, 4, new Uint16Array(2402).map((_, i) => i + 0), 358, 0);
} catch {}
let textureView179 = texture63.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
renderPassEncoder9.beginOcclusionQuery(158);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup45);
} catch {}
try {
buffer100.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer93, 32, new Uint32Array(14887).map((_, i) => i * 4), 2828, 12);
} catch {}
let bindGroup62 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 0, resource: {buffer: buffer138}},
    {binding: 4, resource: textureView113},
    {binding: 44, resource: {buffer: buffer124, size: 28}},
  ],
});
let texture186 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 45},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture187 = device1.createTexture({
  size: {width: 150, height: 20, depthOrArrayLayers: 85},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler34 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 99.61,
  compare: 'not-equal',
});
try {
renderBundleEncoder36.setVertexBuffer(1, buffer157);
} catch {}
try {
commandEncoder152.resolveQuerySet(querySet3, 14, 1, buffer129, 0);
} catch {}
try {
gpuCanvasContext0.configure({device: device1, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
} catch {}
let texture188 = device0.createTexture({
  size: [120, 120, 26],
  dimension: '2d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline32);
} catch {}
let promise26 = device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule6}});
let bindGroup63 = device0.createBindGroup({layout: autogeneratedBindGroupLayout13, entries: [{binding: 0, resource: {buffer: buffer98}}]});
let textureView180 = texture108.createView({});
let renderPassEncoder26 = commandEncoder58.beginRenderPass({
  colorAttachments: [{
  view: textureView81,
  clearValue: { r: 858.5, g: 442.5, b: 830.9, a: 724.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet2, beginningOfPassWriteIndex: 4294967295},
});
let texture189 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder17.setBindGroup(1, bindGroup34);
} catch {}
try {
buffer17.unmap();
} catch {}
let autogeneratedBindGroupLayout16 = pipeline28.getBindGroupLayout(0);
let commandEncoder180 = device1.createCommandEncoder({});
let texture190 = device1.createTexture({
  size: {width: 300, height: 40, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture191 = device1.createTexture({
  size: {width: 75, height: 10, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderBundleEncoder26.setBindGroup(2, bindGroup50, new Uint32Array(10000), 1_356, 0);
} catch {}
let img2 = await imageWithData(15, 2, '#10101010', '#20202020');
let buffer164 = device0.createBuffer({size: 296, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder6.setPipeline(pipeline7);
} catch {}
let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 77, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 122,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 123,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 256,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 325,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 372,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
  ],
});
let bindGroup64 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 4, resource: {buffer: buffer88}},
    {binding: 43, resource: textureView3},
    {binding: 11, resource: {buffer: buffer53}},
    {binding: 229, resource: {buffer: buffer143}},
  ],
});
let commandEncoder181 = device0.createCommandEncoder({});
let texture192 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let texture193 = gpuCanvasContext4.getCurrentTexture();
try {
renderBundleEncoder0.setBindGroup(0, bindGroup61, new Uint32Array(5032), 1_332, 1);
} catch {}
let shaderModule9 = device1.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

enable f16;

@id(36447) override override21: u32 = (1259402612 % 103) + 1;

@id(1843) override override28: u32;

struct VertexOutput7 {
  @location(13) location_13: f32,
  @location(4) location_4: f16,
  @location(12) @interpolate(flat, either) location_12: f32,
  @location(11) @interpolate(flat, first) location_11: f16,
  @location(6) location_6: i32,
  @invariant @builtin(position) position: vec4f,
}

override override27: i32;

override override30: u32;

override override31 = 0.1136;

fn unconst_bool(v: bool) -> bool { return v; }

fn unconst_f16(v: f16) -> f16 { return v; }

struct T1 {
  @align(8) @size(1192) f0: atomic<i32>,
}

@id(5515) override override29: f16;

struct VertexInput41 {
  @location(8) location_8: vec4h,
  @location(2) @interpolate(flat, first) location_2: i32,
  @location(15) @interpolate(linear, first) location_15: vec4f,
  @location(5) location_5: f32,
  @location(10) @interpolate(perspective) location_10: f32,
  @location(13) location_13: u32,
  @location(12) location_12: u32,
  @location(14) location_14: vec2i,
  @location(0) @interpolate(flat, center) location_0: vec2u,
  @location(7) @interpolate(flat, sample) location_7: vec2i,
  @location(9) location_9: vec2i,
}

@group(1) @binding(2) var<uniform> buffer166: array<array<vec4i, 74>, 1>;

struct FragmentOutput8 {
  @location(0) location_0: vec4i,
  @location(1) @interpolate(flat) location_1: i32,
  @builtin(sample_mask) sample_mask: u32,
}

@id(51159) override override19: u32;

fn unconst_f32(v: f32) -> f32 { return v; }

struct T0 {
  f0: vec2i,
  @size(32) f1: vec4f,
  @size(1152) f2: array<array<vec4<bool>, 1>, 36>,
}

override override22: u32 = (1578275560 % 103) + 1;

struct VertexInput42 {
  @location(6) @interpolate(flat, sample) location_6: vec4h,
  @location(1) location_1: vec2i,
  @location(11) location_11: vec4i,
}

@id(48752) override override24: f32;

@id(18494) override override25: f16;

@group(0) @binding(2) var<uniform> buffer165: array<vec4u, 1>;

@id(40512) override override23: f16 = 57215.7;

override override26: i32 = 725336450;

@id(51398) override override20: f16;

fn unconst_u32(v: u32) -> u32 { return v; }

struct FragmentInput18 {
  @location(13) location_13: f32,
}

var<workgroup> vw12: atomic<u32>;

struct FragmentInput19 {
  @location(6) location_6: i32,
  @location(4) location_4: f16,
}

fn unconst_i32(v: i32) -> i32 { return v; }

/* zero global variables used */
@vertex @must_use
fn vertex8(a0: VertexInput41, a1: VertexInput42, @builtin(vertex_index) vertex_index: u32) -> VertexOutput7 {
  var out: VertexOutput7;
  let vf92: vec4h = a0.location_8;
  out.location_6 *= i32(out.position[bitcast<u32>(out.location_13)]);
  let vf93: u32 = vertex_index;
  var vf94: f16 = sign(unconst_f16(1848.3));
  let vf95: vec3f = exp(vec3f(unconst_f32(0.00427), unconst_f32(0.1251), unconst_f32(0.1868e4)));
  switch u32(exp2(f32(vertex_index))) { 
  case default {
  out.location_12 *= f32(out.location_11);
  out.location_12 = bitcast<vec2f>(a0.location_0.xy).y;
  out.location_11 += vec4h(a1.location_11)[2];
  let vf96: vec2i = a0.location_9;
  while bool(a0.location_8.x) {
  let vf97: u32 = a0.location_12;
  break;
}
  break;
}
  }
  var vf98: f16 = vf92[unconst_u32(181535772)];
  return out;
}

/* used global variables: buffer166 */
@fragment
fn fragment10() -> FragmentOutput8 {
  var out: FragmentOutput8;
  out.location_0 += vec4i(buffer166[0][73][unconst_u32(418748964)]);
  out.sample_mask &= u32((*&buffer166)[0][unconst_u32(520913729)].b);
  var vf99: i32 = (*&buffer166)[0][unconst_u32(564656836)][unconst_u32(343982410)];
  let vf100: vec2f = asinh(vec2f(unconst_f32(0.7009), unconst_f32(0.3772)));
  let ptr102: ptr<uniform, vec4i> = &(*&buffer166)[0][73];
  out.location_0 &= vec4i(bitcast<i32>(out.sample_mask));
  return out;
  _ = buffer166;
}

/* used global variables: buffer165, buffer166 */
@fragment
fn fragment11(a0: FragmentInput18, a1: FragmentInput19) -> @location(200) @interpolate(flat, either) vec4i {
  var out: vec4i;
  var vf101: i32 = a1.location_6;
  vf101 *= buffer166[0][73].b;
  var vf102: FragmentInput18 = a0;
  let vf103: u32 = pack2x16snorm(vec2f(unconst_f32(0.1147e-10), unconst_f32(0.02754e-30)));
  vf101 &= i32(faceForward(vec2f(unconst_f32(0.4551), unconst_f32(0.3337)), vec2f(unconst_f32(0.1083e-2), unconst_f32(0.1104e19)), vec2f(unconst_f32(0.09721e26), unconst_f32(-0.07104)))[1]);
  out = vec4i(buffer165[unconst_u32(1781595795)]);
  let vf104: vec4h = sin(vec4h(override25));
  let vf105: ptr<uniform, array<array<vec4i, 74>, 1>> = &buffer166;
  var vf106: u32 = buffer165[unconst_u32(196724940)][unconst_u32(960918)];
  return out;
  _ = override25;
  _ = buffer166;
  _ = buffer165;
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 2)
fn compute8(@builtin(workgroup_id) workgroup_id: vec3u) {
  atomicCompareExchangeWeak(&vw12, unconst_u32(874897625), unconst_u32(1150405260));
  var vf107: vec3f = asin(vec3f(unconst_f32(0.1848), unconst_f32(0.05716e-13), unconst_f32(0.04488)));
  let vf108: f32 = vf107[unconst_u32(431460110)];
  var vf109: u32 = override19;
  let vf110: f32 = override24;
  let vf111: vec2u = firstLeadingBit(vec2u(unconst_u32(551490505), unconst_u32(746514525)));
  vf109 -= u32((unconst_bool(true) || unconst_bool(true)));
  vf109 <<= vec3u(asin(vec3f(unconst_f32(0.04215), unconst_f32(0.1649e15), unconst_f32(0.05276))).xxz)[1];
  _ = override24;
  _ = override19;
}`,
});
let bindGroup65 = device1.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 4, resource: textureView110}]});
let buffer167 = device1.createBuffer({size: 2344, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let textureView181 = texture131.createView({baseMipLevel: 0, baseArrayLayer: 4, arrayLayerCount: 3});
try {
computePassEncoder35.setBindGroup(2, bindGroup51, new Uint32Array(368), 37, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder25.setBindGroup(2, bindGroup54, []);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer145, 'uint16', 4, 2);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(0, buffer110);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(4, buffer105, 44);
} catch {}
try {
device1.queue.writeBuffer(buffer105, 60, new Float64Array(3165).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/3162)), 250, 4);
} catch {}
let texture194 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder14.setBindGroup(2, bindGroup20);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup40, new Uint32Array(47), 0, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(0, buffer75);
} catch {}
let texture195 = device1.createTexture({
  size: [150, 20, 1],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView182 = texture157.createView({aspect: 'all', baseMipLevel: 1, mipLevelCount: 1});
try {
renderPassEncoder25.setPipeline(pipeline20);
} catch {}
let videoFrame25 = new VideoFrame(videoFrame23, {timestamp: 0});
let texture196 = device0.createTexture({size: [128], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder11.setBindGroup(0, bindGroup14, new Uint32Array(1478), 18, 0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline4);
} catch {}
let commandEncoder182 = device0.createCommandEncoder({});
let texture197 = device0.createTexture({
  size: [30],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let pipeline34 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
let commandEncoder183 = device0.createCommandEncoder({});
try {
renderPassEncoder16.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, undefined);
} catch {}
try {
commandEncoder99.resolveQuerySet(querySet1, 68, 56, buffer25, 2560);
} catch {}
try {
renderBundleEncoder5.insertDebugMarker('\u0f49');
} catch {}
try {
device0.queue.writeBuffer(buffer142, 48, new BigInt64Array(14012).map((_, i) => BigInt(i - 6)), 3121, 16);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer102, 'uint16', 80, 0);
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(56); };
} catch {}
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpteRp431', transfer: 'logSqrt'} });
let commandEncoder184 = device0.createCommandEncoder({});
let texture198 = device0.createTexture({
  size: [128, 128, 26],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder22.setIndexBuffer(buffer47, 'uint16', 40, 11);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(1, buffer104, 0);
} catch {}
try {
commandEncoder179.copyBufferToBuffer(buffer59, 20, buffer70, 44, 8);
} catch {}
try {
commandEncoder96.copyTextureToTexture({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 11},
  aspect: 'all',
},
{
  texture: texture163,
  mipLevel: 0,
  origin: {x: 6, y: 3, z: 0},
  aspect: 'all',
},
{width: 7, height: 8, depthOrArrayLayers: 0});
} catch {}
let textureView183 = texture190.createView({dimension: '2d-array'});
try {
computePassEncoder33.setBindGroup(2, bindGroup58);
} catch {}
try {
computePassEncoder34.setBindGroup(3, bindGroup57, new Uint32Array(1624), 127, 0);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline20);
} catch {}
try {
device1.queue.writeBuffer(buffer125, 0, new Float32Array(3451).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.765)), 69, 4);
} catch {}
document.body.append(img0);
let texture199 = device1.createTexture({
  size: {width: 75},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder25.setBindGroup(1, bindGroup48, [0]);
} catch {}
try {
renderPassEncoder25.setBindGroup(3, bindGroup51, new Uint32Array(2923), 115, 0);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer145, 'uint32', 4, 12);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer159, 'uint32', 88, 104);
} catch {}
try {
computePassEncoder34.insertDebugMarker('\u02a5');
} catch {}
try {
device1.queue.writeBuffer(buffer138, 28, new Uint32Array(2117).map((_, i) => i * 4), 90, 0);
} catch {}
let promise27 = device1.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(34); };
} catch {}
try {
  await promise27;
} catch {}
let bindGroup66 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 4, resource: textureView110},
    {binding: 44, resource: {buffer: buffer106}},
    {binding: 0, resource: {buffer: buffer138}},
  ],
});
let commandEncoder185 = device1.createCommandEncoder({});
let textureView184 = texture181.createView({dimension: '3d'});
try {
renderPassEncoder25.setBindGroup(3, bindGroup66, new Uint32Array(298), 95, 1);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline20);
} catch {}
let commandEncoder186 = device0.createCommandEncoder({});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 69, y: 11 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 4, depthOrArrayLayers: 0});
} catch {}
let buffer168 = device1.createBuffer({size: 374, usage: GPUBufferUsage.MAP_WRITE});
let texture200 = device1.createTexture({
  size: {width: 37},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder27 = commandEncoder162.beginRenderPass({
  colorAttachments: [{
  view: textureView169,
  depthSlice: 24,
  clearValue: { r: -319.4, g: 790.3, b: 845.2, a: -172.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  depthStencilAttachment: {
    view: textureView124,
    depthClearValue: 2.536641816084959,
    depthReadOnly: true,
    stencilLoadOp: 'load',
    stencilStoreOp: 'store',
  },
  occlusionQuerySet: querySet3,
  maxDrawCount: 265901232,
});
try {
renderPassEncoder27.setBindGroup(1, bindGroup55, new Uint32Array(1620), 57, 0);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer160, 'uint32', 0, 38);
} catch {}
try {
device1.queue.submit([]);
} catch {}
let buffer169 = device1.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder187 = device1.createCommandEncoder({});
let bindGroup67 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 44, resource: {buffer: buffer106}},
    {binding: 0, resource: {buffer: buffer109}},
    {binding: 4, resource: textureView151},
  ],
});
let texture201 = device1.createTexture({
  size: [300, 40, 1],
  mipLevelCount: 3,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderBundleEncoder33.setBindGroup(0, bindGroup54, new Uint32Array(1809), 284, 0);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer159, 'uint16', 4, 137);
} catch {}
try {
renderBundleEncoder32.setPipeline(pipeline33);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(6, buffer169);
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(33); };
} catch {}
let textureView185 = texture154.createView({});
try {
renderPassEncoder20.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(132);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let buffer170 = device1.createBuffer({
  size: 32,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture202 = device1.createTexture({
  size: [37],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder27.setPipeline(pipeline20);
} catch {}
try {
buffer138.unmap();
} catch {}
await gc();
let bindGroup68 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 4, resource: textureView151},
    {binding: 44, resource: {buffer: buffer109}},
    {binding: 0, resource: {buffer: buffer135}},
  ],
});
let textureView186 = texture186.createView({dimension: '2d', format: 'rgba8uint', baseArrayLayer: 3});
let renderPassEncoder28 = commandEncoder152.beginRenderPass({
  colorAttachments: [{
  view: textureView169,
  depthSlice: 457,
  clearValue: { r: 155.3, g: 592.2, b: -470.5, a: 852.7, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  depthStencilAttachment: {
    view: textureView157,
    depthClearValue: -2.698382323384636,
    stencilClearValue: 48755,
    stencilLoadOp: 'load',
    stencilStoreOp: 'discard',
  },
  maxDrawCount: 372776726,
});
try {
renderPassEncoder28.setVertexBuffer(2, buffer169, 24);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(6, buffer105, 0, 29);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let promise28 = device1.queue.onSubmittedWorkDone();
let commandEncoder188 = device1.createCommandEncoder({});
let textureView187 = texture181.createView({mipLevelCount: 1});
try {
renderPassEncoder25.setIndexBuffer(buffer162, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup59);
} catch {}
try {
computePassEncoder35.setBindGroup(3, bindGroup62, [0]);
} catch {}
try {
commandEncoder140.copyTextureToBuffer({
  texture: texture191,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 176 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 16 */
  offset: 16,
  buffer: buffer130,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise28;
} catch {}
let bindGroup69 = device1.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 0, resource: {buffer: buffer124, size: 48}}, {binding: 4, resource: textureView113}],
});
let commandEncoder189 = device1.createCommandEncoder({});
let texture203 = device1.createTexture({
  size: [37, 5, 42],
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder28.setBindGroup(2, bindGroup55);
} catch {}
try {
gpuCanvasContext2.configure({device: device1, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'});
} catch {}
let promise29 = device1.queue.onSubmittedWorkDone();
let commandEncoder190 = device1.createCommandEncoder({});
try {
renderPassEncoder27.setVertexBuffer(0, buffer110, 16, 16);
} catch {}
try {
renderBundleEncoder32.setPipeline(pipeline22);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let buffer171 = device0.createBuffer({size: 28, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder191 = device0.createCommandEncoder({});
try {
renderPassEncoder7.setPipeline(pipeline0);
} catch {}
try {
buffer95.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 120, depthOrArrayLayers: 49}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 17, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder192 = device0.createCommandEncoder({});
let texture204 = device0.createTexture({
  size: {width: 80, height: 60, depthOrArrayLayers: 22},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder9.setVertexBuffer(5, buffer48);
} catch {}
try {
commandEncoder118.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 444 */
  offset: 444,
  bytesPerRow: 49920,
  buffer: buffer136,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 9, y: 3, z: 0},
  aspect: 'all',
}, {width: 14, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let textureView188 = texture140.createView({aspect: 'stencil-only', format: 'stencil8', baseMipLevel: 3, baseArrayLayer: 53, arrayLayerCount: 7});
try {
computePassEncoder26.setBindGroup(0, bindGroup57);
} catch {}
try {
computePassEncoder30.setBindGroup(2, bindGroup59, new Uint32Array(2930), 629, 0);
} catch {}
try {
commandEncoder163.resolveQuerySet(querySet3, 58, 8, buffer129, 0);
} catch {}
try {
renderPassEncoder25.insertDebugMarker('\u5699');
} catch {}
try {
gpuCanvasContext0.configure({device: device1, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'display-p3'});
} catch {}
let commandEncoder193 = device0.createCommandEncoder({});
let textureView189 = texture204.createView({baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 1});
try {
computePassEncoder10.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.setStencilReference(80);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline6);
} catch {}
try {
commandEncoder74.copyTextureToBuffer({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 9, y: 3, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 476 */
  offset: 476,
  bytesPerRow: 12800,
  buffer: buffer93,
}, {width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer172 = device0.createBuffer({size: 164, usage: GPUBufferUsage.INDIRECT});
try {
computePassEncoder16.setBindGroup(2, bindGroup31);
} catch {}
try {
computePassEncoder15.setBindGroup(3, bindGroup2, new Uint32Array(553), 113, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup12, new Uint32Array(5427), 76, 0);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(2, buffer73, 0, 9);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder194 = device0.createCommandEncoder({});
let texture205 = device0.createTexture({
  size: {width: 20, height: 15, depthOrArrayLayers: 82},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer101, 0); };
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup0, new Uint32Array(192), 11, 0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer48, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer161, 256, new DataView(new ArrayBuffer(34516)), 2324, 312);
} catch {}
let bindGroup70 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout13,
  entries: [{binding: 0, resource: {buffer: buffer98, offset: 0}}],
});
let texture206 = device0.createTexture({
  size: [128, 128, 55],
  mipLevelCount: 4,
  sampleCount: 1,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder8.setVertexBuffer(0, buffer58);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise29;
} catch {}
let bindGroup71 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 11, resource: {buffer: buffer68}},
    {binding: 229, resource: {buffer: buffer141, size: 160}},
    {binding: 43, resource: textureView3},
    {binding: 4, resource: {buffer: buffer161, offset: 1024}},
  ],
});
let commandEncoder195 = device0.createCommandEncoder();
try {
computePassEncoder18.insertDebugMarker('\u0726');
} catch {}
let imageData30 = new ImageData(44, 56);
let renderPassEncoder29 = commandEncoder153.beginRenderPass({
  colorAttachments: [{view: textureView182, depthSlice: 41, loadOp: 'clear', storeOp: 'store'}],
  depthStencilAttachment: {
    view: textureView135,
    depthClearValue: 3.358017438512338,
    depthReadOnly: true,
    stencilClearValue: 58906,
    stencilLoadOp: 'clear',
    stencilStoreOp: 'store',
  },
});
try {
renderPassEncoder27.setBindGroup(3, bindGroup54);
} catch {}
let buffer173 = device0.createBuffer({
  size: 128,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder196 = device0.createCommandEncoder({});
try {
computePassEncoder16.end();
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup53);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer12, 'uint16', 10, 15);
} catch {}
try {
device0.queue.writeBuffer(buffer152, 52, new Float32Array(9324).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.08901)), 673, 0);
} catch {}
let buffer174 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder197 = device0.createCommandEncoder({});
let texture207 = gpuCanvasContext0.getCurrentTexture();
let textureView190 = texture119.createView({dimension: '2d', baseArrayLayer: 1});
try {
renderPassEncoder5.setIndexBuffer(buffer12, 'uint16', 38, 6);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(5, buffer17, 168);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
let imageBitmap2 = await createImageBitmap(imageData29);
let texture208 = device0.createTexture({size: [120, 120, 77], format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC});
try {
renderBundleEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(643), 20, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder122.copyBufferToTexture({
  /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 16 */
  offset: 16,
  bytesPerRow: 22528,
  buffer: buffer46,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: videoFrame23,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 41,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 46,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 398,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '2d-array' },
    },
    {binding: 509, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let commandEncoder198 = device0.createCommandEncoder({});
let textureView191 = texture192.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder9.setBindGroup(2, bindGroup47, new Uint32Array(3607), 841, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img1);
let bindGroup72 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 0, resource: {buffer: buffer157}},
    {binding: 4, resource: textureView110},
    {binding: 44, resource: {buffer: buffer155, size: 18}},
  ],
});
let renderPassEncoder30 = commandEncoder189.beginRenderPass({
  colorAttachments: [{
  view: textureView169,
  depthSlice: 171,
  clearValue: { r: -100.8, g: -621.4, b: 612.6, a: -43.42, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  depthStencilAttachment: {
    view: textureView111,
    depthClearValue: -5.550927288094762,
    depthReadOnly: true,
    stencilClearValue: 6233,
    stencilLoadOp: 'clear',
    stencilStoreOp: 'discard',
  },
});
try {
computePassEncoder33.setPipeline(pipeline27);
} catch {}
try {
renderBundleEncoder30.setBindGroup(2, bindGroup58);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
let commandBuffer1 = commandEncoder46.finish({});
let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder9.setBindGroup(3, bindGroup37, new Uint32Array(79), 16, 0);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(6, buffer141, 0, 29);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup3);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  toneMapping: {mode: 'extended'},
});
} catch {}
let shaderModule10 = device1.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

requires packed_4x8_integer_dot_product;

enable f16;

requires packed_4x8_integer_dot_product;

var<private> vp9: vec2f = vec2f(0.03266, 0.02863e15);

@id(46802) override override33 = true;

@id(45647) override override41: i32;

struct T7 {
  @size(30) f0: u32,
}

alias vec3b = vec3<bool>;

struct ComputeInput11 {
  @builtin(num_workgroups) num_workgroups: vec3u,
}

@id(7427) override override32 = -447781511;

struct VertexInput51 {
  @location(15) location_15: vec4i,
}

struct VertexInput45 {
  @location(10) @interpolate(flat) location_10: i32,
  @location(4) @interpolate(flat, center) location_4: vec2i,
}

@group(0) @binding(4) var tex16: texture_cube<f32>;

@group(0) @binding(0) var<storage, read_write> buffer175: array<array<array<f16, 1>, 15>>;

struct VertexInput43 {
  @builtin(vertex_index) vertex_index: u32,
}

struct FragmentInput24 {
  @location(11) @interpolate(linear, either) location_11: f16,
}

struct T2 {
  @size(16) f0: atomic<i32>,
}

struct VertexInput49 {
  @location(14) @interpolate(flat) location_14: i32,
}

struct VertexInput48 {
  @location(9) location_9: u32,
}

fn unconst_f32(v: f32) -> f32 { return v; }

struct VertexInput46 {
  @location(3) @interpolate(flat) location_3: vec4i,
}

@id(45152) override override38 = true;

/* used global variables: buffer175 */
fn fn1(a0: ptr<uniform, vec4i>) -> vec4h {
  var out: vec4h;
  buffer175[unconst_u32(339588008)][unconst_u32(257941665)][unconst_u32(651631806)] *= f16(vp10[unconst_u32(118318535)][0]);
  return out;
  _ = buffer175;
}

fn unconst_bool(v: bool) -> bool { return v; }

fn unconst_i32(v: i32) -> i32 { return v; }

struct VertexInput47 {
  @location(11) @interpolate(flat) location_11: f32,
  @location(6) location_6: i32,
}

struct FragmentInput20 {
  @builtin(front_facing) front_facing: bool,
  @location(1) @interpolate(flat, centroid) location_1: vec4i,
  @location(10) @interpolate(flat, centroid) location_10: i32,
}

@id(23986) override override37: f16 = 201.0;

/* used global variables: tex16 */
fn fn0(a0: ptr<storage, f16, read_write>) {
  vp11 = vec2<bool>(vp10[0].gg.yy.yx);
  let vf112: u32 = pack4xI8(vec4i(i32(all(unconst_bool(true)))));
  var vf113: vec2u = textureDimensions(tex16);
  _ = tex16;
}

struct T9 {
  f0: array<u32>,
}

struct FragmentInput22 {
  @builtin(sample_index) sample_index: u32,
}

struct T3 {
  f0: array<u32>,
}

var<private> vp10: array<vec2i, 1> = array(vec2i(99448690, 677888539));

override override34: bool;

fn unconst_f16(v: f16) -> f16 { return v; }

struct VertexInput44 {
  @location(0) location_0: vec4f,
  @builtin(instance_index) instance_index: u32,
  @location(2) location_2: vec4i,
  @location(5) @interpolate(perspective) location_5: vec4f,
  @location(7) @interpolate(flat) location_7: u32,
  @location(1) location_1: vec4h,
}

struct FragmentInput23 {
  @location(3) location_3: vec2f,
}

fn unconst_u32(v: u32) -> u32 { return v; }

struct FragmentInput26 {
  @builtin(sample_mask) sample_mask: u32,
}

@id(34209) override override44: f16;

struct T5 {
  f0: array<u32>,
}

struct T4 {
  f0: array<T2>,
}

struct FragmentInput21 {
  @location(0) @interpolate(perspective, first) location_0: vec4h,
  @location(5) location_5: i32,
}

struct T6 {
  @size(30) f0: T0,
}

override override39: f16;

struct ComputeInput9 {
  @builtin(workgroup_id) workgroup_id: vec3u,
}

@id(3870) override override40: i32 = 283501832;

struct T1 {
  f0: vec2h,
  f1: f16,
  @size(24) f2: atomic<i32>,
}

struct T8 {
  f0: array<array<atomic<i32>, 1>>,
}

override override36 = true;

struct ComputeInput10 {
  @builtin(global_invocation_id) global_invocation_id: vec3u,
}

struct T0 {
  @size(16) f0: atomic<u32>,
}

@group(0) @binding(44) var<uniform> buffer176: array<VertexInput46, 1>;

/* zero global variables used */
@must_use 
fn fn2(a0: texture_cube<f32>) -> array<array<array<i32, 1>, 1>, 1> {
  var out: array<array<array<i32, 1>, 1>, 1>;
  for (var it7=u32(override38); it7<(vec3u((vec3i(unconst_i32(295706207), unconst_i32(1262880401), unconst_i32(34778298)) >> vec3u(unconst_u32(316779928), unconst_u32(1453398000), unconst_u32(166676734))).ggg)[2] & 0xfff); it7++) {
  vp11 =  !vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(true)).aa;
}
  let vf114: bool = override35;
  vp9 *= vec2f(bitcast<f32>(out[0][0][0]));
  let ptr103: ptr<function, i32> = &out[0][0][textureNumLevels(a0)];
  let ptr104: ptr<function, i32> = &out[unconst_u32(432865095)][0][unconst_u32(1212652215)];
  return out;
  _ = override38;
  _ = override35;
}

struct FragmentInput25 {
  @builtin(position) position: vec4f,
}

override override43: i32 = 111996250;

var<private> vp11: vec2<bool> = vec2<bool>(true, false);

@id(49653) override override42: bool;

struct VertexOutput8 {
  @location(15) @interpolate(flat) location_15: vec4h,
  @location(4) location_4: vec2i,
  @location(0) location_0: f16,
  @location(10) @interpolate(flat, either) location_10: f32,
  @location(12) location_12: u32,
  @invariant @builtin(position) position: vec4f,
}

override override35: bool;

struct FragmentOutput9 {
  @location(0) @interpolate(flat) location_0: vec4i,
}

struct VertexInput50 {
  @location(8) location_8: i32,
}

/* zero global variables used */
@vertex
fn vertex9(a0: VertexInput43, a1: VertexInput44, a2: VertexInput45, a3: VertexInput46, a4: VertexInput47, a5: VertexInput48, @location(12) location_12: f32, @location(13) location_13: vec2u, a8: VertexInput49, a9: VertexInput50, a10: VertexInput51) -> VertexOutput8 {
  var out: VertexOutput8;
  let ptr105: ptr<function, vec2i> = &out.location_4;
  let vf115: vec3<bool> = (vec3h(unconst_f16(2314.5), unconst_f16(20091.9), unconst_f16(7313.4)) < vec3h(unconst_f16(32217.7), unconst_f16(4278.3), unconst_f16(25575.2)));
  switch a3.location_3[1] { 
  case default {
  out.location_15 = vec4h(a10.location_15.abar);
  var vf116: vec4<bool> = (vec4h(unconst_f16(9090.6), unconst_f16(1412.8), unconst_f16(1109.9), unconst_f16(8995.3)) > vec4h(unconst_f16(-16131.4), unconst_f16(1607.4), unconst_f16(8263.2), unconst_f16(26676.6)));
  out.position = bitcast<vec4f>(a1.location_2.abbr);
  let ptr106: ptr<private, vec2i> = &vp10[0];
  let ptr107: ptr<function, vec4h> = &out.location_15;
  out.location_10 = a4.location_11;
}
case 461077801: {
  let vf117: f32 = a4.location_11;
  var vf118: vec4i = a3.location_3;
  var vf119: vec2f = unpack2x16float(vec3u(transpose(mat3x4h(unconst_f16(4494.4), unconst_f16(7787.0), unconst_f16(6547.2), unconst_f16(2182.5), unconst_f16(7663.6), unconst_f16(9889.5), unconst_f16(3251.1), unconst_f16(16277.0), unconst_f16(5789.0), unconst_f16(2722.3), unconst_f16(8840.4), unconst_f16(895.9)))[unconst_i32(1)].yyz.zxy.xzz).r);
  var vf120: vec4f = log2(vec4f(unconst_f32(0.01395e-20), unconst_f32(0.2560e14), unconst_f32(0.00200), unconst_f32(0.01478)));
}
case 61733021, 477732659: {
  switch u32(a10.location_15[unconst_u32(1043773733)]) { 
  case 444241839, default: {
  let vf121: f32 = location_12;
  out.location_0 = out.location_15.a;
}
  }
  break;
}
  }
  out.position = vec4f(out.location_15);
  var vf122: VertexInput50 = a9;
  out.position = vec4f(bitcast<f32>(pack4xI8(vec4i(unconst_i32(951933110), unconst_i32(122009523), unconst_i32(1202512285), unconst_i32(399283783)))));
  let vf123: u32 = location_13[unconst_u32(340670924)];
  var vf124: VertexInput46 = a3;
  out.position = vec4f(f32(max(unconst_f16(-18355.2), unconst_f16(4600.0))));
  return out;
}

/* used global variables: buffer175, buffer176, tex16 */
@fragment
fn fragment12(@location(14) @interpolate(flat, sample) location_14: u32, a1: FragmentInput20, a2: FragmentInput21, @location(12) location_12: vec2f, a4: FragmentInput22, a5: FragmentInput23, a6: FragmentInput24, @location(15) @interpolate(perspective) location_15: vec4h, a8: FragmentInput25, a9: FragmentInput26) -> FragmentOutput9 {
  var out: FragmentOutput9;
  var vf125 = fn2(tex16);
  let ptr108: ptr<function, i32> = &vf125[0][unconst_u32(2215126008)][unconst_u32(688222159)];
  vp11 = vec2<bool>(a1.front_facing);
  for (var it8=u32(vf125[0][unconst_u32(60387442)][unconst_u32(377354387)]); it8<(bitcast<u32>(vf125[0][0][0]) & 0xfff); it8++) {
  var vf126 = fn1(&(*&buffer176)[unconst_u32(630805640)].location_3);
  vp11 = vec2<bool>(buffer176[0].location_3.wz);
  let ptr109: ptr<uniform, vec4i> = &buffer176[0].location_3;
  _ = buffer175;
  _ = buffer176;
}
  return out;
  _ = override38;
  _ = override35;
  _ = tex16;
  _ = buffer176;
  _ = buffer175;
}

/* zero global variables used */
@compute @workgroup_size(2, 1, 1)
fn compute9(a0: ComputeInput9, a1: ComputeInput10, a2: ComputeInput11, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) {
  var vf127: bool = vp11[unconst_u32(227704401)];
  vp11 = vec2<bool>(override36);
  vp11 = vp11;
  vp10[unconst_u32(792281408)] -= vec2i(a2.num_workgroups.xy);
  var vf128: vec4u = unpack4xU8(unconst_u32(272610915));
  let vf129: vec3u = a1.global_invocation_id;
  var vf130: i32 = vp10[unconst_u32(915927250)][unconst_u32(242695562)];
  vp9 = unpack2x16unorm(a0.workgroup_id[unconst_u32(6436458)]);
  _ = override36;
}`,
});
let textureView192 = texture202.createView({aspect: 'all'});
let renderPassEncoder31 = commandEncoder180.beginRenderPass({
  colorAttachments: [{
  view: textureView169,
  depthSlice: 384,
  clearValue: { r: 331.1, g: -882.7, b: 860.7, a: 428.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  depthStencilAttachment: {
    view: textureView157,
    depthClearValue: -4.281522679874346,
    depthReadOnly: true,
    stencilClearValue: 38582,
    stencilLoadOp: 'clear',
    stencilStoreOp: 'store',
  },
  maxDrawCount: 171375516,
});
let sampler35 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  maxAnisotropy: 1,
});
try {
renderPassEncoder29.setIndexBuffer(buffer160, 'uint16', 0, 13);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(3, buffer105, 0);
} catch {}
try {
buffer133.unmap();
} catch {}
let buffer177 = device1.createBuffer({size: 260, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder199 = device1.createCommandEncoder({});
let texture209 = device1.createTexture({
  size: {width: 75, height: 10, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView193 = texture147.createView({dimension: '2d', aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 4});
let computePassEncoder38 = commandEncoder163.beginComputePass();
let externalTexture25 = device1.importExternalTexture({source: videoFrame22});
try {
computePassEncoder38.setPipeline(pipeline27);
} catch {}
try {
renderBundleEncoder27.setBindGroup(2, bindGroup62, new Uint32Array(3297), 385, 1);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer159, 'uint16', 488);
} catch {}
try {
renderBundleEncoder30.setPipeline(pipeline20);
} catch {}
try {
device1.queue.submit([]);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline32);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture92,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(162).fill(160), /* required buffer size: 162 */
{offset: 162}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup73 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [
    {binding: 144, resource: {buffer: buffer88}},
    {binding: 37, resource: {buffer: buffer68, offset: 0}},
    {binding: 436, resource: externalTexture1},
  ],
});
let buffer178 = device0.createBuffer({size: 186, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder200 = device0.createCommandEncoder();
try {
computePassEncoder17.setBindGroup(0, bindGroup29);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer152, 'uint16', 86, 52);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer47, 'uint16', 14, 11);
} catch {}
try {
buffer75.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let pipeline35 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, constants: {}}});
document.body.append(canvas0);
let texture210 = device1.createTexture({
  size: {width: 300},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView194 = texture186.createView({baseArrayLayer: 17, arrayLayerCount: 6});
try {
renderPassEncoder31.setPipeline(pipeline33);
} catch {}
try {
renderBundleEncoder29.setBindGroup(0, bindGroup43, [0]);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(3, buffer105, 80, 19);
} catch {}
try {
device1.queue.writeBuffer(buffer105, 124, new Float32Array(2090).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.590)), 210, 12);
} catch {}
let buffer179 = device0.createBuffer({size: 140, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture211 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 65},
  dimension: '2d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder23.setBindGroup(0, bindGroup63, new Uint32Array(1168), 445, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline32);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer60, 'uint16', 6, 6);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 15, depthOrArrayLayers: 1}
*/
{
  source: imageData13,
  origin: { x: 1, y: 2 },
  flipY: false,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder201 = device1.createCommandEncoder({});
let texture212 = device1.createTexture({
  size: {width: 37, height: 5, depthOrArrayLayers: 82},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder26.setBindGroup(3, bindGroup72, [0]);
} catch {}
try {
computePassEncoder26.setBindGroup(2, bindGroup58, new Uint32Array(2160), 61, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer127, 12, new DataView(new ArrayBuffer(44132)), 238, 0);
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 70, resource: {buffer: buffer128, offset: 0, size: 282}}],
});
let texture213 = device0.createTexture({size: [30, 30, 12], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder6.setBindGroup(0, bindGroup74, new Uint32Array(1848), 446, 0);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer72, 'uint32', 28, 7);
} catch {}
let commandEncoder202 = device0.createCommandEncoder({});
let sampler36 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', minFilter: 'linear'});
try {
renderPassEncoder12.setVertexBuffer(2, buffer63, 16);
} catch {}
try {
renderBundleEncoder35.setBindGroup(2, bindGroup53, new Uint32Array(904), 393, 0);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer128, 'uint16', 18, 18);
} catch {}
try {
buffer79.unmap();
} catch {}
let textureView195 = texture180.createView({aspect: 'all', arrayLayerCount: 9});
try {
renderPassEncoder28.setBindGroup(0, bindGroup54, []);
} catch {}
try {
renderPassEncoder27.setBindGroup(2, bindGroup59, new Uint32Array(4322), 342, 0);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer162, 'uint16', 0, 0);
} catch {}
try {
commandEncoder185.copyTextureToBuffer({
  texture: texture190,
  mipLevel: 0,
  origin: {x: 6, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 780 */
  offset: 780,
  bytesPerRow: 3072,
  buffer: buffer167,
}, {width: 1, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture183,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(585).fill(97), /* required buffer size: 585 */
{offset: 585}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
videoFrame2.close();
videoFrame5.close();
videoFrame6.close();
videoFrame7.close();
videoFrame9.close();
videoFrame10.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
}
async function window1() {
let adapter0 = await navigator.gpu.requestAdapter({powerPreference: 'high-performance'});
let promise0 = navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
    'float16-renderable',
    'float32-renderable',
    'core-features-and-limits',
  ],
  requiredLimits: {
    maxSampledTexturesPerShaderStage: 16,
    maxStorageBufferBindingSize: 166673635,
    maxTextureDimension2D: 8192,
    maxUniformBufferBindingSize: 4211958,
    maxVertexBuffers: 8,
  },
});
let buffer0 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder0 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: {width: 1100, height: 256, depthOrArrayLayers: 1},
  format: 'astc-10x8-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let commandEncoder1 = device0.createCommandEncoder({});
let texture1 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder0.clearBuffer(buffer0);
} catch {}
let buffer1 = device0.createBuffer({
  size: 432,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder2 = device0.createCommandEncoder({});
let textureView0 = texture1.createView({dimension: 'cube-array', baseArrayLayer: 0, arrayLayerCount: 6});
try {
device0.pushErrorScope('internal');
} catch {}
try {
adapter0.label = '\uc623\u064b\u{1f8da}\ue1a1\u78b7\u{1fd0a}\u{1fce2}\uecf7\uf16c\u0eaa';
} catch {}
let textureView1 = texture1.createView({dimension: 'cube-array', arrayLayerCount: 6});
let texture2 = device0.createTexture({
  size: [8, 8, 23],
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder0 = commandEncoder1.beginComputePass();
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
let promise1 = device0.queue.onSubmittedWorkDone();
try {
  await promise1;
} catch {}
let commandEncoder3 = device0.createCommandEncoder({});
let texture3 = device0.createTexture({
  size: [24, 24, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: false});
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'film', transfer: 'linear'} });
let videoFrame1 = videoFrame0.clone();
let buffer2 = device0.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let computePassEncoder1 = commandEncoder0.beginComputePass();
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 161,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let texture4 = device0.createTexture({
  size: [1310, 1, 97],
  sampleCount: 1,
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture5 = device0.createTexture({size: {width: 655}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 52, 96);
} catch {}
try {
commandEncoder2.copyBufferToBuffer(buffer2, 0, buffer1, 72, 4);
} catch {}
let imageData0 = new ImageData(16, 64);
try {
device0.label = '\uc4b0\u0722\u5cef\u{1fe90}\ua95b\u{1fec6}\u4022';
} catch {}
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let buffer3 = device0.createBuffer({size: 144, usage: GPUBufferUsage.COPY_DST});
let commandEncoder4 = device0.createCommandEncoder({});
let texture6 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 17},
  mipLevelCount: 3,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'bt2020_12bit'} });
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let buffer4 = device0.createBuffer({size: 181, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let textureView2 = texture6.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 2});
let texture7 = device0.createTexture({
  size: {width: 327},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint'],
});
let textureView3 = texture1.createView({baseArrayLayer: 1, arrayLayerCount: 4});
try {
buffer3.unmap();
} catch {}
try {
commandEncoder2.insertDebugMarker('\u7fe9');
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} });
let sampler0 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.67,
  lodMaxClamp: 89.36,
});
let texture8 = device0.createTexture({
  size: [12, 12, 20],
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder2 = commandEncoder4.beginComputePass();
try {
buffer0.unmap();
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

enable f16;

struct VertexInput1 {
  @location(9) @interpolate(flat, centroid) location_9: vec4i,
  @builtin(vertex_index) vertex_index: u32,
  @location(12) @interpolate(flat, first) location_12: f16,
}

fn unconst_f16(v: f16) -> f16 { return v; }

alias vec3b = vec3<bool>;

struct VertexInput0 {
  @location(1) @interpolate(linear) location_1: vec2h,
  @location(2) @interpolate(flat, sample) location_2: vec2u,
}

struct FragmentInput0 {
  @builtin(front_facing) front_facing: bool,
}

fn unconst_i32(v: i32) -> i32 { return v; }

struct FragmentInput1 {
  @builtin(sample_index) sample_index: u32,
}

fn unconst_f32(v: f32) -> f32 { return v; }

struct ComputeInput2 {
  @builtin(num_workgroups) num_workgroups: vec3u,
}

var<private> vp1: f16 = f16(13509.5);

fn unconst_bool(v: bool) -> bool { return v; }

var<private> vp0 = frexp(vec2f(0.03202e29, 0.5314));

var<private> vp2 = modf(vec2h(12746.9, 4141.2));

struct FragmentOutput0 {
  @location(0) @interpolate(flat) location_0: vec2u,
}

struct ComputeInput1 {
  @builtin(workgroup_id) workgroup_id: vec3u,
}

var<workgroup> vw0: atomic<u32>;

@group(0) @binding(20) var<storage, read> buffer5: array<array<array<vec2f, 12>, 4>>;

struct ComputeInput3 {
  @builtin(global_invocation_id) global_invocation_id: vec3u,
  @builtin(num_workgroups) num_workgroups: vec3u,
}

struct T0 {
  @align(64) f0: array<array<f16, 96>>,
}

struct ComputeInput0 {
  @builtin(local_invocation_id) local_invocation_id: vec3u,
}

fn unconst_u32(v: u32) -> u32 { return v; }

/* zero global variables used */
@vertex @must_use
fn vertex0(@builtin(instance_index) instance_index: u32, a1: VertexInput0, @location(10) location_10: vec2f, @location(15) location_15: vec2f, @location(11) @interpolate(flat) location_11: vec4u, a5: VertexInput1) -> @builtin(position) vec4f {
  var out: vec4f;
  out = vec4f(location_10[unconst_u32(311951331)]);
  return out;
}

/* zero global variables used */
@fragment
fn fragment0(@builtin(sample_mask) sample_mask: u32, a1: FragmentInput0, a2: FragmentInput1) -> FragmentOutput0 {
  var out: FragmentOutput0;
  vp1 = f16(a2.sample_index);
  return out;
}

/* used global variables: buffer5 */
@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(local_invocation_index) local_invocation_index: u32, a1: ComputeInput0, a2: ComputeInput1, a3: ComputeInput2, @builtin(global_invocation_id) global_invocation_id: vec3u) {
  atomicCompareExchangeWeak(&vw0, unconst_u32(816719404), unconst_u32(23416623));
  let ptr0: ptr<storage, vec2f, read> = &buffer5[arrayLength(&buffer5)][unconst_u32(105949802)][11];
  vp1 = vec4h(unpack4xU8(unconst_u32(432482517)))[0];
  vp0 = frexp(buffer5[unconst_i32(54318407)][3][11]);
  _ = buffer5;
}

/* used global variables: buffer5 */
@compute @workgroup_size(2, 1, 1)
fn compute1(a0: ComputeInput3, @builtin(workgroup_id) workgroup_id: vec3u) {
  vp2 = modf(bitcast<vec2h>((*&buffer5)[unconst_u32(406864251)][unconst_u32(1101984359)][11][unconst_u32(88580481)]));
  let vf0: u32 = arrayLength(&buffer5);
  vp0.fract *= (*&buffer5)[unconst_u32(875457969)][3][11];
  vp0.fract *= unpack2x16unorm(arrayLength(&(*&buffer5)));
  vp0 = frexp(vec2f(buffer5[arrayLength(&buffer5)][unconst_u32(67040610)][11][unconst_u32(177354676)]));
  let ptr1: ptr<storage, array<array<vec2f, 12>, 4>, read> = &(*&buffer5)[arrayLength(&(*&buffer5))];
  let ptr2: ptr<storage, array<vec2f, 12>, read> = &buffer5[u32(buffer5[arrayLength(&buffer5)][unconst_u32(378042590)][11][unconst_u32(873663210)])][unconst_u32(194494671)];
  vp0 = frexp((*&buffer5)[arrayLength(&(*&buffer5))][3][unconst_u32(116497877)]);
  vp1 = f16(buffer5[unconst_u32(436120072)][unconst_u32(888880376)][unconst_u32(164415751)][unconst_u32(642445733)]);
  vp0.exp = vec2i((*&buffer5)[arrayLength(&(*&buffer5))][unconst_u32(463837102)][11].rr);
  _ = buffer5;
}`,
});
let buffer6 = device0.createBuffer({size: 132, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture9 = device0.createTexture({
  size: [655, 1, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture10 = device0.createTexture({
  size: [655, 1, 1],
  mipLevelCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let commandEncoder5 = device0.createCommandEncoder({});
let texture11 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 119},
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture12 = device0.createTexture({
  size: [1310, 1, 108],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView4 = texture12.createView({aspect: 'all', format: 'rg8uint', baseMipLevel: 1, mipLevelCount: 1});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder0.insertDebugMarker('\u83c8');
} catch {}
await gc();
let imageBitmap0 = await createImageBitmap(videoFrame2);
let commandEncoder6 = device0.createCommandEncoder({});
let textureView5 = texture4.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2});
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let commandEncoder7 = device0.createCommandEncoder({});
let textureView6 = texture11.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1});
let textureView7 = texture11.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 16});
let sampler1 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.43,
  maxAnisotropy: 16,
});
try {
renderBundleEncoder0.setVertexBuffer(5, buffer6);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let pipelineLayout1 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout1],
});
let commandEncoder8 = device0.createCommandEncoder({});
let textureView8 = texture9.createView({});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let externalTexture0 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'});
try {
buffer6.unmap();
} catch {}
try {
commandEncoder5.copyBufferToBuffer(buffer2, 4, buffer0, 4, 4);
} catch {}
let bindGroup0 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 0, resource: {buffer: buffer6}}, {binding: 1, resource: {buffer: buffer6}}],
});
let pipelineLayout2 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1],
});
let commandEncoder9 = device0.createCommandEncoder({});
let texture13 = device0.createTexture({
  size: [1410, 78, 3],
  mipLevelCount: 1,
  format: 'astc-10x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView9 = texture3.createView({});
let computePassEncoder3 = commandEncoder3.beginComputePass();
let renderPassEncoder0 = commandEncoder5.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -801.1, g: 455.1, b: -92.45, a: -463.0, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 318121429,
});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 104, 5);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer6, 0);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture12,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture14 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  mipLevelCount: 2,
  format: 'eac-rg11unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture15 = device0.createTexture({
  size: [1310, 1, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
let sampler2 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 73.46,
});
try {
renderBundleEncoder2.setIndexBuffer(buffer1, 'uint32', 52, 76);
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'smpte240m'} });
let textureView10 = texture13.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(1017), 123, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer2, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup0, new Uint32Array(466), 42, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer1, 'uint16', 120, 35);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup1 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: {buffer: buffer6}}, {binding: 0, resource: {buffer: buffer6}}],
});
let computePassEncoder4 = commandEncoder8.beginComputePass();
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
computePassEncoder0.setBindGroup(1, bindGroup0, new Uint32Array(1790), 1_750, 0);
} catch {}
let pipeline0 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}});
let pipeline1 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{
  format: 'rg8uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 76,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 0, shaderLocation: 12},
          {format: 'float32', offset: 8, shaderLocation: 15},
          {format: 'uint8x4', offset: 20, shaderLocation: 2},
          {format: 'float16x4', offset: 28, shaderLocation: 10},
          {format: 'uint32', offset: 16, shaderLocation: 11},
          {format: 'sint32x3', offset: 0, shaderLocation: 9},
          {format: 'float32x3', offset: 0, shaderLocation: 1},
        ],
      },
    ],
  },
});
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 9, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 20,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer7 = device0.createBuffer({
  size: 256,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder10 = device0.createCommandEncoder({});
let texture16 = device0.createTexture({
  size: [48, 48, 1],
  mipLevelCount: 3,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture17 = device0.createTexture({
  size: [163],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView11 = texture9.createView({dimension: '2d'});
let renderPassEncoder1 = commandEncoder6.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -512.5, g: -316.7, b: -914.6, a: 326.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let pipeline2 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}});
let texture18 = device0.createTexture({
  size: [6, 6, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView12 = texture4.createView({dimension: '2d', baseArrayLayer: 1});
let renderPassEncoder2 = commandEncoder9.beginRenderPass({colorAttachments: [{view: textureView9, loadOp: 'load', storeOp: 'discard'}]});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, stencilReadOnly: true});
try {
computePassEncoder0.setPipeline(pipeline2);
} catch {}
let canvas0 = document.createElement('canvas');
let texture19 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 26},
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint'],
});
let textureView13 = texture11.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6});
let computePassEncoder5 = commandEncoder7.beginComputePass();
try {
computePassEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer7);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 16},
  aspect: 'all',
}, new Uint8Array(222).fill(196), /* required buffer size: 222 */
{offset: 222}, {width: 321, height: 0, depthOrArrayLayers: 1});
} catch {}
let gpuCanvasContext0 = canvas0.getContext('webgpu');
let texture20 = device0.createTexture({
  size: [327, 1, 6],
  mipLevelCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView14 = texture6.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 1});
try {
computePassEncoder5.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer1, 'uint32', 68, 56);
} catch {}
try {
buffer7.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer1, 40, new DataView(new ArrayBuffer(156924)), 2873, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 130, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(2_137).fill(120), /* required buffer size: 2_137 */
{offset: 27, bytesPerRow: 743}, {width: 390, height: 18, depthOrArrayLayers: 1});
} catch {}
let imageData1 = new ImageData(20, 16);
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 0, resource: {buffer: buffer6}}, {binding: 1, resource: {buffer: buffer6}}],
});
let texture21 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView15 = texture20.createView({dimension: '2d', mipLevelCount: 1});
let renderPassEncoder3 = commandEncoder10.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: 953.6, g: 883.3, b: 479.2, a: 427.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
computePassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder2.setStencilReference(28);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer7, 0);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline1);
} catch {}
await gc();
try {
computePassEncoder5.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder3.setBindGroup(3, bindGroup2, new Uint32Array(2668), 163, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup2, new Uint32Array(1544), 437, 0);
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 2, resource: textureView8}, {binding: 161, resource: externalTexture0}],
});
let commandEncoder11 = device0.createCommandEncoder();
let textureView16 = texture11.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 13});
let texture22 = device0.createTexture({
  size: [24, 24, 1],
  mipLevelCount: 3,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder4 = commandEncoder11.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -583.0, g: 389.6, b: 364.8, a: -847.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 361258285,
});
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(2, buffer6, 0, 8);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let computePassEncoder6 = commandEncoder2.beginComputePass();
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(3847), 329, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 0, new DataView(new ArrayBuffer(1828)), 105, 132);
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'gamma22curve'} });
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

struct T11 {
  f0: array<array<atomic<u32>, 1>>,
}

override override2: i32;

struct T5 {
  @align(128) f0: array<atomic<u32>>,
}

struct T6 {
  f0: array<u32>,
}

struct T4 {
  @align(2) @size(58) f0: bool,
}

struct T9 {
  f0: array<u32>,
}

alias vec3b = vec3<bool>;

fn unconst_f32(v: f32) -> f32 { return v; }

struct T7 {
  @align(32) f0: array<vec4i>,
}

struct T1 {
  f0: array<atomic<i32>>,
}

override override3: bool;

struct T8 {
  @size(176) f0: T4,
}

override override1: f32;

struct T3 {
  @align(64) f0: array<array<array<atomic<u32>, 1>, 1>>,
}

struct ComputeInput4 {
  @builtin(workgroup_id) workgroup_id: vec3u,
}

struct T2 {
  @align(128) f0: array<array<array<atomic<i32>, 1>, 1>>,
}

/* zero global variables used */
fn fn1() {
  let vf9: vec3u = select(vec3u(unconst_u32(385826229), unconst_u32(1049758089), unconst_u32(8582546)), vec3u(unconst_u32(254193972), unconst_u32(1039786940), unconst_u32(1553595942)), unconst_bool(false));
  let vf10: vec4i = insertBits(vec4i(unconst_i32(72970644), unconst_i32(585648035), unconst_i32(571640481), unconst_i32(311140275)), vec4i(unconst_i32(257094930), unconst_i32(129299730), unconst_i32(1723939094), unconst_i32(340978599)), unconst_u32(234324059), unconst_u32(245152213));
}

struct T12 {
  f0: array<u32>,
}

@group(0) @binding(1) var<storage, read_write> buffer9: T2;

struct T10 {
  f0: T4,
}

fn unconst_bool(v: bool) -> bool { return v; }

@group(0) @binding(0) var<storage, read_write> buffer8: array<array<f16, 29>>;

/* zero global variables used */
fn fn0(a0: array<array<vec2f, 1>, 4>) -> i32 {
  var out: i32;
  out = vec4i(unpack4x8snorm(unconst_u32(48933845)).yyxz.xzzx.ggaa.rbbg.yzyz)[1];
  out += bitcast<i32>(pack4xU8Clamp(reverseBits(vec4u(unconst_u32(646620594), unconst_u32(338653333), unconst_u32(677484612), unconst_u32(218541895)))));
  out ^= bitcast<vec3i>(step(vec3f(cos(vec4h(f16(override1))).ggr), step(vec3f(unconst_f32(0.03642e-33), unconst_f32(-0.2157), unconst_f32(0.02184e-15)), vec3f(unconst_f32(0.4315), unconst_f32(0.1045), unconst_f32(-0.1076)))))[2];
  let vf1: vec4f = unpack4x8snorm(unconst_u32(575974109));
  let vf2: f32 = ldexp(unconst_f32(0.02506), unconst_i32(780964341));
  let vf3: u32 = pack4x8snorm(vec4f(unconst_f32(0.08096e26), unconst_f32(0.04220), unconst_f32(0.05752e5), unconst_f32(0.1662)));
  let vf4: vec3h = cross(vec3h(unconst_f16(7400.7), unconst_f16(35036.4), unconst_f16(5061.3)), vec3h(unconst_f16(5597.6), unconst_f16(1496.5), unconst_f16(7090.1)));
  {
  let vf5: vec3h = cross(vec3h(unconst_f16(2574.5), unconst_f16(4831.7), unconst_f16(3465.7)), vec3h(unconst_f16(8966.7), unconst_f16(964.0), unconst_f16(19562.7)));
  out -= out;
  let vf6: vec2i = (vec2i(unconst_i32(332447763), unconst_i32(387112644)) << vec2u(unconst_u32(1362205167), unconst_u32(140414605)));
  switch bitcast<vec2u>(vf6.yx.yx.gg.xx)[1] { 
  case default, 1605168793: {
  var vf7: vec3i = reverseBits(vec3i(unconst_i32(301003227), unconst_i32(-14725), unconst_i32(-251252327)));
  for (var it0=bitcast<u32>(vf7[dot(vec2u(unconst_u32(608443876), unconst_u32(1081809715)), vec2u(unconst_u32(757580179), unconst_u32(5073112)))]); it0<(u32((unconst_f32(0.02869e-19) == unconst_f32(0.00864e-22))) & 0xfff); it0++) {
  out += i32(a0[3][0][1]);
  out &= bitcast<i32>(unpack2x16snorm(unconst_u32(58952174)).x);
  out = bitcast<vec2i>(a0[unconst_u32(254329218)][0].gr)[1];
}
  vf7 |= vec3i(i32(determinant(mat4x4h(vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(2)].xzxy.gbag.bbaa), vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(2)].zyxy), vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(2)].zxzz), vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(1)].zyxx.wzzy)))));
  break;
}
  }
}
  let vf8: vec2f = a0[unconst_u32(3095911674)][unconst_u32(1919724915)];
  out = bitcast<i32>(a0[unconst_u32(231457642)][unconst_u32(769525788)][unconst_u32(444755722)]);
  return out;
  _ = override1;
}

fn unconst_f16(v: f16) -> f16 { return v; }

struct T13 {
  f0: vec2h,
}

struct T0 {
  @align(32) f0: array<u32>,
}

override override0: f16 = 4032.7;

struct FragmentOutput1 {
  @location(4) @interpolate(flat, centroid) location_4: vec2i,
  @location(0) @interpolate(flat) location_0: vec4u,
}

fn unconst_u32(v: u32) -> u32 { return v; }

fn unconst_i32(v: i32) -> i32 { return v; }

/* used global variables: buffer9 */
@fragment
fn fragment1() -> FragmentOutput1 {
  var out: FragmentOutput1;
  let ptr3: ptr<storage, array<atomic<i32>, 1>, read_write> = &(*&buffer9).f0[arrayLength(&(*&buffer9).f0)][unconst_u32(502603174)];
  return out;
  _ = buffer9;
}

/* used global variables: buffer8 */
@compute @workgroup_size(2, 1, 1)
fn compute2(a0: ComputeInput4, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u) {
  var vf11: vec2h = ((*&buffer8)[unconst_u32(38745630)][unconst_u32(1450638908)] / vec2h(unconst_f16(8027.3), unconst_f16(4102.3)));
  let ptr4: ptr<storage, array<f16, 29>, read_write> = &(*&buffer8)[unconst_i32(421435266)];
  var vf12: vec3<bool> =  !vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false));
  vf12 = vec3<bool>(bool((*ptr4)[unconst_u32(335644331)]));
  buffer8[unconst_u32(4294967295)][unconst_u32(1242241640)] = (unconst_f16(3102.4) / vec2h(unconst_f16(31451.0), unconst_f16(8692.1)))[0];
  vf12 = vec3<bool>(bool(reverseBits(unconst_i32(308681980))));
  {
  buffer8[unconst_u32(394491349)][unconst_u32(1233394499)] = f16(a0.workgroup_id[0]);
  switch u32((*&buffer8)[arrayLength(&(*&buffer8))][unconst_u32(209750462)]) { 
  case 15709278, default {
  var vf13: u32 =  ~u32(buffer8[unconst_u32(1646656802)][28]);
  for (var jj84=0u; jj84<31; jj84++) { buffer8[unconst_u32(389344808)][jj84] += vec3h(extractBits(vec3i(unconst_i32(-799924787), unconst_i32(16797496), unconst_i32(35349488)), unconst_u32(1238330324), u32((*&buffer8)[arrayLength(&(*&buffer8))][28])).rbr.rgg.xyy.yyy).x; }
  _ = buffer8;
}
  }
  buffer8[unconst_u32(1015993436)][28] = f16(arrayLength(&buffer8));
  let vf14: vec3u = global_invocation_id;
  _ = buffer8;
}
  vf11 *= bitcast<vec2h>(pack2x16float(vec2f(unconst_f32(0.03362e35), unconst_f32(0.1061e-36))));
  _ = buffer8;
}`,
});
let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(0);
let commandEncoder12 = device0.createCommandEncoder({});
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float'],
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 80, new DataView(new ArrayBuffer(117600)), 22, 28);
} catch {}
let pipeline3 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule1, entryPoint: 'fragment1', targets: [{format: 'rg8uint'}]},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 564, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 628, shaderLocation: 1},
          {format: 'float32', offset: 76, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 52,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x2', offset: 4, shaderLocation: 10}],
      },
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [{format: 'sint16x4', offset: 0, shaderLocation: 9}, {format: 'uint8x2', offset: 0, shaderLocation: 2}],
      },
      {
        arrayStride: 188,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 52, shaderLocation: 11}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front'},
});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer1, 'uint32', 16, 164);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(5, buffer7);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new Uint32Array(5551).map((_, i) => i * 4), 3203, 0);
} catch {}
let commandEncoder13 = device0.createCommandEncoder({});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
let sampler3 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 40.65,
});
try {
renderPassEncoder1.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup2, new Uint32Array(232), 23, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'bt2020_12bit'} });
let texture23 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
let texture24 = gpuCanvasContext0.getCurrentTexture();
let textureView17 = texture4.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 11});
let computePassEncoder7 = commandEncoder13.beginComputePass();
try {
renderBundleEncoder5.setIndexBuffer(buffer1, 'uint16', 22, 67);
} catch {}
try {
computePassEncoder1.setBindGroup(1, bindGroup3, new Uint32Array(906), 50, 0);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 76, 39);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer1, 'uint16', 14, 36);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline1);
} catch {}
try {
commandEncoder12.copyBufferToTexture({
  /* bytesInLastRow: 510 widthInBlocks: 255 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 168 */
  offset: 168,
  buffer: buffer7,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 81, y: 0, z: 0},
  aspect: 'all',
}, {width: 255, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder4.insertDebugMarker('\u9d5f');
} catch {}
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpteSt4281', transfer: 'bt709'} });
let bindGroup4 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 0, resource: {buffer: buffer7}}, {binding: 1, resource: {buffer: buffer7}}],
});
let texture25 = gpuCanvasContext0.getCurrentTexture();
let textureView18 = texture8.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 3});
try {
computePassEncoder3.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer2, 0);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup2, []);
} catch {}
let promise3 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
let imageData2 = new ImageData(80, 8);
let buffer10 = device0.createBuffer({size: 164, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture26 = device0.createTexture({
  size: [327, 1, 68],
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView19 = texture16.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(706), 57, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer1, 168);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup2);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer1, 'uint16', 42, 21);
} catch {}
try {
commandEncoder12.copyTextureToBuffer({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 146 widthInBlocks: 73 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 14 */
  offset: 14,
  buffer: buffer10,
}, {width: 73, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer7, 4, 14);
} catch {}
let videoFrame8 = new VideoFrame(videoFrame0, {timestamp: 0});
try {
computePassEncoder2.setBindGroup(2, bindGroup1, new Uint32Array(823), 242, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(221), 13, 0);
} catch {}
try {
renderPassEncoder4.draw(464, 0, 1_052_702_023);
} catch {}
try {
buffer4.unmap();
} catch {}
let buffer11 = device0.createBuffer({size: 352, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture27 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 150},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView20 = texture13.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 0});
try {
computePassEncoder7.setBindGroup(0, bindGroup3, new Uint32Array(861), 140, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup1);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 44, new Float32Array(4125).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.03017)), 63, 4);
} catch {}
let texture28 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder2.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer1, 16);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer1, 'uint32', 28, 42);
} catch {}
try {
buffer6.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer1, 16, new DataView(new ArrayBuffer(136)), 5, 4);
} catch {}
let texture29 = device0.createTexture({
  size: [6, 6, 18],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let texture30 = gpuCanvasContext0.getCurrentTexture();
let renderPassEncoder5 = commandEncoder12.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -278.3, g: 993.3, b: -766.6, a: -349.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
renderBundleEncoder3.label = '\u6734\ufdd1\u5177\u7465\uf890\u7a33\u0e3f\u9250\ud5f3\u6425';
} catch {}
let buffer12 = device0.createBuffer({size: 84, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture31 = device0.createTexture({
  size: [24, 24, 75],
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
buffer7.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer3, 64, new Float32Array(14370).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.306)), 983, 0);
} catch {}
document.body.append(canvas0);
try {
computePassEncoder0.setBindGroup(0, bindGroup1, new Uint32Array(9284), 853, 0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
let commandEncoder14 = device0.createCommandEncoder({});
let texture32 = device0.createTexture({size: [24], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
let textureView21 = texture16.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 2});
let computePassEncoder8 = commandEncoder14.beginComputePass();
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(29).fill(171), /* required buffer size: 29 */
{offset: 29, rowsPerImage: 12}, {width: 598, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline4 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let bindGroup5 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 2, resource: textureView11}, {binding: 161, resource: externalTexture0}],
});
let buffer13 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST});
try {
computePassEncoder7.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline3);
} catch {}
let autogeneratedBindGroupLayout1 = pipeline2.getBindGroupLayout(0);
let bindGroup6 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 161, resource: externalTexture0}, {binding: 2, resource: textureView12}],
});
let commandEncoder15 = device0.createCommandEncoder({});
let texture33 = gpuCanvasContext0.getCurrentTexture();
try {
renderBundleEncoder3.setPipeline(pipeline3);
} catch {}
try {
commandEncoder15.copyTextureToTexture({
  texture: texture22,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture17,
  mipLevel: 0,
  origin: {x: 58, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
adapter0.label = '\u331e\u53ef\uc4d5\u{1f8a0}\u0816\u1989\u652f';
} catch {}
try {
device0.label = '\uc601\uc311\u0c98\u{1f6b2}\udfac\u4eab\u05df';
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer7, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
document.body.append(canvas0);
let imageData3 = new ImageData(164, 8);
let texture34 = device0.createTexture({
  size: {width: 24},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
document.body.append(canvas0);
let textureView22 = texture34.createView({});
let texture35 = device0.createTexture({
  size: [8, 8, 13],
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder9 = commandEncoder15.beginComputePass();
try {
renderPassEncoder2.setBlendConstant({ r: 350.8, g: 293.9, b: 93.33, a: 952.1, });
} catch {}
try {
renderPassEncoder5.draw(347, 1, 27_252_069);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 10, 19);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer7, 0);
} catch {}
let buffer14 = device0.createBuffer({
  size: 20,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder16 = device0.createCommandEncoder({});
let textureView23 = texture21.createView({label: '\u{1faba}\u0906\u{1f641}\u056b', dimension: 'cube', baseArrayLayer: 1});
let renderPassEncoder6 = commandEncoder16.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -159.2, g: 595.0, b: -176.4, a: 724.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 110925521,
});
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer2, 0, 5);
} catch {}
try {
computePassEncoder2.insertDebugMarker('\u0def');
} catch {}
try {
  await promise2;
} catch {}
let commandEncoder17 = device0.createCommandEncoder();
let textureView24 = texture27.createView({});
try {
computePassEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(1899), 18, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder5.draw(741, 1, 1_710_886_560);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer1, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer14, 'uint32', 0, 8);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup5, new Uint32Array(3366), 594, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(1, buffer2, 0, 0);
} catch {}
document.body.append(canvas0);
let buffer15 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder18 = device0.createCommandEncoder({});
let textureView25 = texture34.createView({});
try {
renderPassEncoder5.drawIndexed(2, 1, 0, 41_897_117);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 4, new Float32Array(494).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6466)), 51, 0);
} catch {}
let pipeline5 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let texture36 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture37 = device0.createTexture({
  size: [6, 6, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder10 = commandEncoder17.beginComputePass();
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(605), 75, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer14, 'uint16', 0, 3);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline1);
} catch {}
let autogeneratedBindGroupLayout2 = pipeline0.getBindGroupLayout(0);
let textureView26 = texture36.createView({baseArrayLayer: 0});
let textureView27 = texture10.createView({baseMipLevel: 0});
let sampler4 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
computePassEncoder6.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder5.draw(156, 1, 1_510_866_816);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer15, 'uint32', 0, 11);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer13.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new Uint16Array(16739).map((_, i) => i + 8), 1164, 12);
} catch {}
await gc();
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer6}}],
});
let buffer16 = device0.createBuffer({size: 28, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder19 = device0.createCommandEncoder({});
let texture38 = device0.createTexture({
  size: {width: 8},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder5.draw(7, 1, 260_209_397);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer1, 28);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer6, 0, 6);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup1, new Uint32Array(126), 26, 0);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(7, buffer2, 0, 6);
} catch {}
try {
buffer7.unmap();
} catch {}
try {
computePassEncoder0.pushDebugGroup('\ub8c3');
} catch {}
let texture39 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder10.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder5.draw(293, 1, 112_996_766);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline3);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 16, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 108, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {binding: 194, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let commandEncoder20 = device0.createCommandEncoder({});
let textureView28 = texture38.createView({baseArrayLayer: 0});
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer15, 'uint32', 0, 0);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Float16Array(4455).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.090)), 172, 0);
} catch {}
await gc();
try {
textureView1.label = '\u013f\u2e08\u0e44';
} catch {}
let commandEncoder21 = device0.createCommandEncoder({label: '\u{1fdd6}\u4a03\u{1fb93}\u{1fa7c}\u{1f6c1}\uddc9\u067a\u29d2\u0768\u{1f89a}'});
let textureView29 = texture11.createView({label: '\u05bd\u7037', dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 29});
let renderPassEncoder7 = commandEncoder12.beginRenderPass({colorAttachments: [{view: textureView15, loadOp: 'load', storeOp: 'store'}]});
try {
commandEncoder20.copyTextureToTexture({
  texture: texture12,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 7},
  aspect: 'all',
},
{
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder11 = commandEncoder20.beginComputePass();
try {
gpuCanvasContext0.unconfigure();
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

enable f16;

@group(1) @binding(5) var<storage, read> buffer19: array<f32, 4>;

struct T3 {
  f0: array<u32>,
}

fn unconst_f32(v: f32) -> f32 { return v; }

@group(1) @binding(134) var<storage, read_write> buffer21: array<array<f16, 43>>;

@group(2) @binding(134) var<storage, read_write> buffer23: array<array<array<f16, 43>, 1>>;

struct T0 {
  @size(180) f0: vec2u,
}

@group(1) @binding(9) var<storage, read_write> buffer20: array<array<array<array<f16, 1>, 1>, 1504>>;

struct T5 {
  @size(128) f0: T4,
}

struct FragmentInput3 {
  @builtin(sample_mask) sample_mask: u32,
}

@group(0) @binding(1) var<storage, read_write> buffer18: T5;

struct T6 {
  f0: vec2h,
  f1: array<atomic<u32>>,
}

struct T4 {
  @size(58) f0: atomic<i32>,
}

@group(0) @binding(0) var<storage, read_write> buffer17: array<array<array<array<array<array<f16, 29>, 1>, 1>, 1>, 1>>;

struct T1 {
  f0: array<atomic<u32>>,
}

fn unconst_i32(v: i32) -> i32 { return v; }

fn unconst_bool(v: bool) -> bool { return v; }

fn unconst_u32(v: u32) -> u32 { return v; }

struct ComputeInput6 {
  @builtin(workgroup_id) workgroup_id: vec3u,
}

struct ComputeInput5 {
  @builtin(global_invocation_id) global_invocation_id: vec3u,
}

fn unconst_f16(v: f16) -> f16 { return v; }

struct T2 {
  @align(64) f0: array<array<array<vec4i, 3>, 1>>,
}

struct FragmentInput2 {
  @builtin(sample_index) sample_index: u32,
}

struct FragmentOutput2 {
  @location(0) @interpolate(flat) location_0: vec4u,
  @location(7) @interpolate(flat, either) location_7: vec2i,
}

/* used global variables: buffer17, buffer18, buffer20 */
@fragment
fn fragment2(a0: FragmentInput2, @builtin(position) position: vec4f, a2: FragmentInput3) -> FragmentOutput2 {
  var out: FragmentOutput2;
  out.location_0 <<= unpack4xU8(u32((*&buffer17)[arrayLength(&(*&buffer17))][bitcast<u32>(cosh(vec3f(unconst_f32(0.1642e-34), unconst_f32(0.02640), unconst_f32(0.01986)))[2])][0][unconst_u32(948466367)][unconst_u32(352467284)][28]));
  let ptr5: ptr<storage, array<f16, 29>, read_write> = &buffer17[arrayLength(&buffer17)][unconst_u32(315355846)][0][0][unconst_u32(980513835)];
  let ptr6: ptr<storage, f16, read_write> = &(*&buffer17)[arrayLength(&(*&buffer17))][0][0][unconst_u32(152782352)][0][unconst_u32(296651728)];
  atomicXor(&buffer18.f0.f0, unconst_i32(214379720));
  discard;
  out.location_7 *= vec2i(i32((*&buffer20)[unconst_u32(1210900295)][unconst_u32(304394186)][unconst_u32(91040635)][0]));
  let ptr7: ptr<storage, f16, read_write> = &(*&buffer17)[u32(buffer17[arrayLength(&buffer17)][unconst_u32(98590128)][unconst_u32(1668899117)][unconst_u32(1606252374)][0][28])][0][0][0][unconst_u32(783931955)][28];
  out.location_7 = vec2i(i32((*&buffer17)[arrayLength(&(*&buffer17))][0][u32((*&buffer17)[arrayLength(&(*&buffer17))][0][0][0][unconst_u32(960182495)][28])][0][unconst_u32(521790752)][28]));
  return out;
  _ = buffer17;
  _ = buffer20;
  _ = buffer18;
}

/* used global variables: buffer17, buffer19, buffer21, buffer23 */
@compute @workgroup_size(2, 1, 3)
fn compute3(a0: ComputeInput5, @builtin(num_workgroups) num_workgroups: vec3u, a2: ComputeInput6) {
  if bool(buffer17[arrayLength(&buffer17)][0][0][0][unconst_u32(172124662)][28]) {
  for (var ii31=0u; ii31<0x1000; ii31+=0x11) { buffer21[ii31][unconst_u32(1671194573)] += (*&buffer17)[arrayLength(&(*&buffer17))][0][0][u32(buffer23[arrayLength(&buffer23)][unconst_u32(198959512)][42])][unconst_u32(978659652)][unconst_u32(411242398)]; }
  buffer21[unconst_u32(1354530929)][42] *= (*&buffer17)[arrayLength(&(*&buffer17))][0][unconst_u32(255627641)][0][0][28];
  let ptr8: ptr<storage, f16, read_write> = &(*&buffer17)[unconst_u32(52313731)][unconst_u32(1748987500)][0][0][unconst_u32(309012799)][unconst_u32(437752196)];
  _ = buffer17;
  _ = buffer23;
  _ = buffer21;
}
  buffer21[unconst_u32(544882257)][unconst_u32(604265770)] = buffer17[unconst_u32(233720024)][0][0][0][0][28];
  for (var jj87=0u; jj87<3; jj87++) { buffer17[u32(buffer17[arrayLength(&buffer17)][unconst_u32(88789492)][unconst_u32(438112116)][unconst_u32(128551247)][unconst_u32(85697975)][unconst_u32(1359434921)])][unconst_u32(135634090)][jj87][unconst_u32(538995344)][unconst_u32(760761537)][unconst_u32(163428371)] = (*&buffer17)[arrayLength(&(*&buffer17))][unconst_u32(11743473)][unconst_u32(175754256)][unconst_u32(126556569)][0][28]; }
  let ptr9: ptr<storage, array<f16, 29>, read_write> = &buffer17[arrayLength(&buffer17)][0][unconst_u32(661666232)][0][0];
  for (var ii78=0u; ii78<0x1000; ii78+=0x11) { buffer23[ii78][unconst_u32(645245315)][unconst_u32(750405639)] = (*&buffer21)[arrayLength(&(*&buffer21))][42]; }
  buffer21[unconst_u32(823664580)][unconst_u32(881768182)] -= (*&buffer17)[arrayLength(&(*&buffer17))][0][u32((*&buffer23)[unconst_u32(1332218338)][0][42])][0][unconst_u32(463001209)][unconst_u32(914638428)];
  let ptr10: ptr<storage, f16, read_write> = &(*&buffer17)[arrayLength(&(*&buffer17))][unconst_u32(748378838)][0][unconst_u32(730341544)][0][28];
  let ptr11: ptr<storage, f16, read_write> = &(*&buffer17)[unconst_u32(1584405990)][unconst_u32(61423881)][0][bitcast<u32>((*&buffer19)[3])][0][28];
  let ptr12: ptr<storage, array<array<array<array<array<array<f16, 29>, 1>, 1>, 1>, 1>>, read_write> = &(*&buffer17);
  _ = buffer21;
  _ = buffer23;
  _ = buffer17;
  _ = buffer19;
}`,
});
let buffer24 = device0.createBuffer({
  size: 39,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder22 = device0.createCommandEncoder({});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 257});
try {
computePassEncoder3.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder2.setBindGroup(3, bindGroup7, new Uint32Array(394), 14, 0);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 4, new Float32Array(2576).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.9649)), 93, 0);
} catch {}
let renderPassEncoder8 = commandEncoder21.beginRenderPass({
  colorAttachments: [{
  view: textureView24,
  depthSlice: 33,
  clearValue: { r: 367.8, g: 128.5, b: 601.4, a: -772.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder6.setBindGroup(1, bindGroup6, new Uint32Array(1951), 55, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(2, buffer7, 0, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData4 = new ImageData(32, 36);
let commandEncoder23 = device0.createCommandEncoder();
try {
renderBundleEncoder2.setBindGroup(2, bindGroup1);
} catch {}
let buffer25 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX, mappedAtCreation: false});
try {
renderBundleEncoder13.setIndexBuffer(buffer15, 'uint32', 0, 1);
} catch {}
try {
buffer24.unmap();
} catch {}
try {
commandEncoder23.copyBufferToBuffer(buffer14, 0, buffer0, 28, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 12, new Float32Array(864).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.047)), 18, 0);
} catch {}
let commandEncoder24 = device0.createCommandEncoder({});
let texture40 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder4.end();
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(7, buffer6);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let texture41 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 150},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView30 = texture12.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder12 = commandEncoder19.beginComputePass();
let renderPassEncoder9 = commandEncoder11.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: -455.7, g: -57.12, b: -129.8, a: -199.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer15, 'uint16', 0, 2);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(3, buffer6);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 0, new Float32Array(4992).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.5147)), 489, 0);
} catch {}
let textureView31 = texture17.createView({mipLevelCount: 1});
try {
computePassEncoder4.setBindGroup(3, bindGroup4, new Uint32Array(1194), 390, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.draw(394, 1, 263_467_137, 0);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer4, 100);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer15, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer1, 'uint16', 58, 22);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline3);
} catch {}
let buffer26 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder25 = device0.createCommandEncoder();
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
computePassEncoder12.setBindGroup(0, bindGroup3);
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires packed_4x8_integer_dot_product;

struct FragmentInput5 {
  @builtin(sample_mask) sample_mask: u32,
  @location(14) @interpolate(flat) location_14: vec2i,
}

fn unconst_u32(v: u32) -> u32 { return v; }

struct VertexInput4 {
  @location(10) @interpolate(linear, center) location_10: vec4h,
  @location(5) location_5: u32,
  @location(0) location_0: vec4h,
  @location(4) @interpolate(flat) location_4: vec2u,
  @location(13) @interpolate(flat, either) location_13: vec2u,
}

alias vec3b = vec3<bool>;

struct FragmentInput11 {
  @builtin(sample_index) sample_index: u32,
}

@group(0) @binding(0) var<storage, read_write> buffer27: array<array<f16, 29>>;

struct FragmentInput7 {
  @location(9) location_9: vec4h,
  @location(6) @interpolate(flat, either) location_6: i32,
}

struct T0 {
  @size(58) f0: array<vec2f, 3>,
}

struct VertexInput3 {
  @location(1) location_1: vec4u,
}

fn unconst_i32(v: i32) -> i32 { return v; }

@group(0) @binding(1) var<storage, read_write> buffer28: array<array<FragmentInput6, 8>>;

struct FragmentInput6 {
  @location(5) @interpolate(flat, center) location_5: vec4i,
}

/* used global variables: buffer27 */
@must_use 
fn fn0(a0: ptr<function, vec4<bool>>) -> vec2f {
  var out: vec2f;
  (*a0) = vec4<bool>(cosh(vec2f(f32(arrayLength(&(*&buffer27))))).xxxy);
  return out;
  _ = buffer27;
}

struct VertexOutput0 {
  @location(5) @interpolate(flat) location_5: vec4i,
  @location(9) location_9: vec4h,
  @location(10) @interpolate(flat, first) location_10: u32,
  @location(0) location_0: i32,
  @location(13) location_13: vec4i,
  @location(2) @interpolate(perspective, centroid) location_2: f32,
  @builtin(position) position: vec4f,
  @location(14) @interpolate(flat, center) location_14: vec2i,
  @location(6) @interpolate(flat, either) location_6: i32,
  @location(4) @interpolate(perspective) location_4: vec2h,
  @location(3) @interpolate(flat, centroid) location_3: f16,
}

var<workgroup> vw1: array<atomic<i32>, 1>;

fn unconst_f32(v: f32) -> f32 { return v; }

struct VertexInput2 {
  @location(15) location_15: f32,
  @location(3) location_3: f32,
  @location(12) location_12: vec4u,
  @builtin(vertex_index) vertex_index: u32,
}

struct FragmentInput4 {
  @location(4) @interpolate(perspective, center) location_4: vec2h,
}

struct FragmentOutput4 {
  @location(0) location_0: vec4u,
  @location(1) @interpolate(perspective) location_1: vec2f,
}

fn unconst_f16(v: f16) -> f16 { return v; }

var<private> vp3: vec2i = vec2i(36294720, 307454328);

struct FragmentInput10 {
  @builtin(sample_mask) sample_mask: u32,
}

struct FragmentOutput3 {
  @location(0) @interpolate(flat) location_0: vec4u,
  @builtin(sample_mask) sample_mask: u32,
}

struct FragmentInput8 {
  @location(2) @interpolate(perspective, centroid) location_2: f32,
}

struct FragmentInput9 {
  @location(0) location_0: i32,
  @location(10) @interpolate(flat, first) location_10: u32,
  @builtin(front_facing) front_facing: bool,
}

/* used global variables: buffer27, buffer28 */
fn fn1(a0: ptr<storage, f16, read_write>) {
  buffer28[unconst_u32(249433788)][unconst_u32(261174566)].location_5 &= vec4i(unpack4x8unorm(unconst_u32(980389416)));
  (*a0) = f16(vp3[unconst_u32(667823807)]);
  buffer28[unconst_u32(946438070)][unconst_u32(672904290)].location_5 *= (*&buffer28)[arrayLength(&(*&buffer28))][unconst_u32(276554769)].location_5;
  let vf15: u32 = arrayLength(&buffer27);
  let vf16: f32 = smoothstep(unconst_f32(0.06839), f32(abs(unconst_f16(-6704.5))), unconst_f32(0.00547));
  (*a0) = (*&buffer27)[arrayLength(&(*&buffer27))][28];
  var vf17: vec2f = unpack2x16snorm(unconst_u32(803549340));
  _ = buffer27;
  _ = buffer28;
}

fn unconst_bool(v: bool) -> bool { return v; }

/* zero global variables used */
@vertex
fn vertex1(a0: VertexInput2, @location(8) location_8: vec2f, @location(2) location_2: f32, a3: VertexInput3, a4: VertexInput4, @location(7) @interpolate(linear) location_7: vec2h) -> @builtin(position) vec4f {
  var out: vec4f;
  out += vec4f(a4.location_10);
  out -= unpack4x8unorm(pack2x16snorm(vec2f(unconst_f32(0.05219e-8), unconst_f32(-0.1229e22))));
  var vf18: f32 = location_8[unconst_u32(156688282)];
  return out;
}

/* zero global variables used */
@vertex
fn vertex2() -> VertexOutput0 {
  var out: VertexOutput0;
  if any( !vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(true))) {
  out.location_4 *= vec2h(out.location_14.xx.xx);
}
  out.location_0 -= bitcast<i32>(unpack4x8unorm(unconst_u32(17138128))[0]);
  out.location_0 = i32((unconst_i32(52265602) != unconst_i32(-956688982)));
  let vf19: vec3f = abs(vec3f(unconst_f32(0.09461), unconst_f32(0.3318e12), unconst_f32(0.3035e11)));
  out.position *= bitcast<vec4f>(out.location_14.xyxx.yyzw);
  out.location_0 = i32(determinant(mat2x2h()));
  out.location_14 = vec2i(i32(out.location_10));
  return out;
}

/* used global variables: buffer27, buffer28 */
@fragment
fn fragment3(a0: FragmentInput4, @location(3) location_3: f16, a2: FragmentInput5, a3: FragmentInput6, @location(13) @interpolate(flat, center) location_13: vec4i, a5: FragmentInput7, a6: FragmentInput8, a7: FragmentInput9) -> FragmentOutput3 {
  var out: FragmentOutput3;
  for (var it1=bitcast<u32>(a0.location_4); it1<(pack2x16unorm(asin(vec2f(unconst_f32(0.1321e0), unconst_f32(0.00694)))) & 0xfff); it1++) {
  while bool((*&buffer27)[arrayLength(&(*&buffer27))][unconst_u32(461152616)]) {
  while bool(cosh(vec2h(unconst_f16(8844.7), unconst_f16(447.6)))[0]) {
  out.sample_mask *= u32(buffer27[arrayLength(&buffer27)][28]);
  let ptr13: ptr<storage, FragmentInput6, read_write> = &buffer28[unconst_u32(194026909)][unconst_u32(2129661160)];
  return out;
  _ = buffer28;
  _ = buffer27;
}
  fn1(&buffer27[arrayLength(&buffer27)][unconst_u32(202951355)]);
  switch pack4xI8((*&buffer28)[arrayLength(&(*&buffer28))][unconst_u32(874149904)].location_5) { 
  default {
  let vf20: u32 = pack2x16snorm(vec2f(unconst_f32(0.6401e11), unconst_f32(-0.06925)));
}
  }
  return out;
  _ = buffer27;
  _ = buffer28;
}
  _ = buffer27;
  _ = buffer28;
}
  loop {
  fn1(&(*&buffer27)[arrayLength(&(*&buffer27))][28]);
  out.sample_mask &= u32(location_3);
  out.location_0 += vec4u((*&buffer28)[arrayLength(&(*&buffer28))][7].location_5);
  break;
  _ = buffer27;
  _ = buffer28;
}
  out.sample_mask >>= pack4xI8Clamp(buffer28[unconst_u32(1023468921)][unconst_u32(125140198)].location_5);
  let ptr14: ptr<storage, FragmentInput6, read_write> = &(*&buffer28)[unconst_u32(677613547)][unconst_u32(556677106)];
  return out;
  _ = buffer28;
  _ = buffer27;
}

/* used global variables: buffer27, buffer28 */
@fragment
fn fragment4(a0: FragmentInput10, a1: FragmentInput11, @builtin(front_facing) front_facing: bool) -> FragmentOutput4 {
  var out: FragmentOutput4;
  out.location_0 &= vec4u(u32((*&buffer27)[unconst_u32(28145043)][28]));
  switch vec3i(min(vec3f(unconst_f32(0.07495), unconst_f32(0.1203), unconst_f32(0.07386e16)), vec3f(unconst_f32(0.00895), unconst_f32(0.1541e-26), unconst_f32(0.07495e2)))).z { 
  case 373858473, 757868269, 116729796, 523329663 {
  let ptr15: ptr<storage, FragmentInput6, read_write> = &buffer28[arrayLength(&buffer28)][unconst_u32(869159148)];
  _ = buffer28;
}
case default: {
  buffer28[unconst_u32(8608783)][unconst_u32(329166974)] = FragmentInput6(vec4i(radians(vec3f(unconst_f32(0.1526), unconst_f32(0.1388e20), unconst_f32(0.07443e-20))).ggrb));
  vp3 = buffer28[arrayLength(&buffer28)][7].location_5.rb;
  out.location_0 = unpack4xU8(u32((*&buffer28)[arrayLength(&(*&buffer28))][unconst_u32(806119821)].location_5[unconst_u32(2506959909)]));
  let ptr16: ptr<storage, array<FragmentInput6, 8>, read_write> = &(*&buffer28)[arrayLength(&(*&buffer28)) - 1];
  buffer28[unconst_u32(47770106)][unconst_u32(143014293)].location_5 *= (*ptr16)[unconst_u32(4162355)].location_5;
  {
  let ptr17: ptr<storage, array<FragmentInput6, 8>, read_write> = &(*&buffer28)[unconst_u32(913884742)];
  for (var it2=a0.sample_mask; it2<(bitcast<u32>((*&buffer28)[unconst_u32(824550075)][7].location_5.r) & 0xfff); it2++) {
  buffer28[unconst_u32(2131611664)][unconst_u32(537666678)].location_5 = vec4i(i32((*&buffer27)[unconst_u32(1415733748)][28]));
  let vf21: i32 = (*&buffer28)[arrayLength(&(*&buffer28))][7].location_5[unconst_u32(174837906)];
  _ = buffer28;
  _ = buffer27;
}
  vp3 -= vec2i(i32(a1.sample_index));
  _ = buffer27;
  _ = buffer28;
}
  _ = buffer27;
  _ = buffer28;
}
  }
  out = FragmentOutput4(vec4u(buffer28[arrayLength(&buffer28)][u32((*&buffer27)[arrayLength(&(*&buffer27)) - 1][28])].location_5), bitcast<vec2f>(buffer28[arrayLength(&buffer28)][u32((*&buffer27)[arrayLength(&(*&buffer27)) - 1][28])].location_5.gg));
  out.location_1 = bitcast<vec2f>((*&buffer28)[unconst_u32(1144395396)][7].location_5.xw.rg);
  return out;
  _ = buffer27;
  _ = buffer28;
}

/* used global variables: buffer27 */
@compute @workgroup_size(3, 1, 1)
fn compute4(@builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u) {
  let ptr18: ptr<workgroup, atomic<i32>> = &(*&vw1)[unconst_u32(352273314)];
  buffer27[unconst_u32(50634417)][unconst_u32(123582463)] = refract(vec3h(unconst_f16(8134.3), unconst_f16(18979.2), unconst_f16(24795.5)), vec3h(unconst_f16(1632.0), unconst_f16(1110.3), unconst_f16(413.6)), unconst_f16(11810.9)).x;
  let vf22: ptr<workgroup, array<atomic<i32>, 1>> = &vw1;
  vp3 |= vec2i(i32((*&buffer27)[arrayLength(&(*&buffer27))][28]));
  atomicSub(&vw1[0], i32(dot(vec2h(unconst_f16(21650.5), unconst_f16(13134.7)), vec2h(unconst_f16(9614.4), unconst_f16(14309.8)))));
  for (var it3=pack4xU8(vec4u((vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(false)) != vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true), unconst_bool(true))))); it3<(u32((*&buffer27)[arrayLength(&(*&buffer27))][unconst_u32(2450581182)]) & 0xfff); it3++) {
  vp3 = vec2i(bitcast<i32>(global_invocation_id[unconst_u32(114022757)]));
}
  for (var jj11=0u; jj11<3; jj11++) { atomicCompareExchangeWeak(&vw1[jj11], unconst_i32(20442721), unconst_i32(33987627)); }
  return;
  _ = buffer27;
}`,
});
let sampler5 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMaxClamp: 51.20,
  maxAnisotropy: 1,
});
try {
renderPassEncoder0.drawIndexedIndirect(buffer1, 16);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer24, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer7);
} catch {}
try {
commandEncoder23.resolveQuerySet(querySet0, 20, 14, buffer11, 0);
} catch {}
try {
computePassEncoder0.popDebugGroup();
} catch {}
try {
device0.queue.label = '\u358d\u{1fbff}';
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup6, new Uint32Array(905), 222, 0);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer1, 40);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer25, 'uint32', 4, 3);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(3, buffer7);
} catch {}
let textureView32 = texture7.createView({format: 'rg8uint', mipLevelCount: 1});
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer14, 'uint16', 0, 2);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline3);
} catch {}
try {
commandEncoder23.clearBuffer(buffer0);
} catch {}
let commandEncoder26 = device0.createCommandEncoder({});
let textureView33 = texture16.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder9.setIndexBuffer(buffer15, 'uint32', 0, 4);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder2.drawIndexedIndirect(buffer1, 0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeBuffer(buffer25, 0, new DataView(new Uint8Array(898).map((_, i) => i).buffer), 258, 12);
} catch {}
let bindGroup8 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer6}}],
});
try {
renderPassEncoder1.setIndexBuffer(buffer15, 'uint16', 4, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup6, new Uint32Array(543), 56, 0);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer4, 84);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(2, buffer6);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let pipeline6 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule0, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE}]},
  vertex: {module: shaderModule3, entryPoint: 'vertex2', buffers: []},
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'back'},
});
let buffer29 = device0.createBuffer({
  label: '\u{1fcd6}\u4c7e\u1930\u3ab5\u5ab8',
  size: 680,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView34 = texture5.createView({aspect: 'all'});
try {
computePassEncoder4.setBindGroup(2, bindGroup3, new Uint32Array(526), 8, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup0, new Uint32Array(2578), 1_878, 0);
} catch {}
try {
renderPassEncoder9.beginOcclusionQuery(145);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer25, 'uint32', 32);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer29, 640);
} catch {}
let bindGroup9 = device0.createBindGroup({
  label: '\ufb8f\u0fe9\u9e16\u0fc4\u0ac8\ub466\u6f8e\u{1fcd4}',
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 2, resource: textureView5}, {binding: 161, resource: externalTexture0}],
});
try {
computePassEncoder1.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: -494.4, g: 216.9, b: 733.9, a: 924.7, });
} catch {}
let buffer30 = device0.createBuffer({size: 360, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
try {
renderBundleEncoder0.setBindGroup(2, bindGroup9);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer1, 8);
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'pq'} });
let bindGroup10 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 0, resource: {buffer: buffer7}}, {binding: 1, resource: {buffer: buffer30}}],
});
let texture42 = device0.createTexture({
  size: [6, 6, 70],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder10.setBindGroup(2, bindGroup3);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline1);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let textureView35 = texture42.createView({dimension: '2d', baseArrayLayer: 2});
let texture43 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderBundleEncoder2.drawIndexed(4, 1, 2, 201_791_132);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline1);
} catch {}
let commandBuffer0 = commandEncoder5.finish();
let computePassEncoder13 = commandEncoder25.beginComputePass();
let renderBundle0 = renderBundleEncoder2.finish({label: '\u{1f707}\u{1fe38}'});
try {
computePassEncoder13.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup8);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 88, new DataView(new ArrayBuffer(33888)), 45, 0);
} catch {}
let pipeline7 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 1},
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32x3', offset: 104, shaderLocation: 15},
          {format: 'snorm16x4', offset: 720, shaderLocation: 10},
          {format: 'snorm16x2', offset: 156, shaderLocation: 1},
          {format: 'uint32x3', offset: 1076, shaderLocation: 2},
          {format: 'uint32x3', offset: 352, shaderLocation: 11},
          {format: 'sint8x4', offset: 864, shaderLocation: 9},
          {format: 'float32x2', offset: 52, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'},
});
document.body.prepend(canvas0);
let commandEncoder27 = device0.createCommandEncoder({});
let texture44 = device0.createTexture({
  size: {width: 24},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder9.setVertexBuffer(0, buffer29);
} catch {}
try {
commandEncoder26.clearBuffer(buffer3);
} catch {}
let textureView36 = texture36.createView({aspect: 'all', format: 'rgba8uint'});
let texture45 = device0.createTexture({size: [655, 1, 33], mipLevelCount: 5, format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
let textureView37 = texture16.createView({dimension: '2d-array', mipLevelCount: 1});
let renderPassEncoder10 = commandEncoder26.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -112.3, g: 82.89, b: -247.8, a: 564.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder2.setBindGroup(2, bindGroup4, new Uint32Array(1529), 31, 0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(3, buffer2);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline6);
} catch {}
document.body.append(canvas0);
let img0 = await imageWithData(77, 76, '#10101010', '#20202020');
let autogeneratedBindGroupLayout3 = pipeline3.getBindGroupLayout(0);
let bindGroup11 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 1, resource: {buffer: buffer6, offset: 0}}],
});
let texture46 = device0.createTexture({
  size: {width: 1310},
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture47 = device0.createTexture({
  size: [12, 12, 37],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView38 = texture19.createView({format: 'rg8uint', mipLevelCount: 1, baseArrayLayer: 13, arrayLayerCount: 1});
try {
computePassEncoder11.setBindGroup(2, bindGroup8, new Uint32Array(4695), 204, 0);
} catch {}
try {
renderBundleEncoder13.draw(263, 21, 1_232_531_802, 554_167_373);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer4, 4);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer15, 'uint32', 0, 1);
} catch {}
let computePassEncoder14 = commandEncoder24.beginComputePass();
let sampler6 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'less',
  maxAnisotropy: 16,
});
try {
computePassEncoder3.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer24, 'uint16', 4, 7);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer15, 0);
} catch {}
document.body.prepend(canvas0);
let renderPassEncoder11 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: 14.32, g: -44.10, b: -350.8, a: -884.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder3.setIndexBuffer(buffer25, 'uint32', 0, 4);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup3);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 0, resource: {buffer: buffer7, offset: 0}}, {binding: 1, resource: {buffer: buffer6}}],
});
let commandEncoder28 = device0.createCommandEncoder({});
let textureView39 = texture11.createView({dimension: 'cube-array', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 13, arrayLayerCount: 6});
try {
computePassEncoder2.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
renderBundleEncoder13.draw(159, 230, 70_471_643, 1_688_669_647);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(5, buffer2);
} catch {}
try {
renderBundleEncoder9.insertDebugMarker('\u2bc3');
} catch {}
let commandEncoder29 = device0.createCommandEncoder({});
try {
computePassEncoder10.setBindGroup(1, bindGroup9, new Uint32Array(447), 99, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline6);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new Uint32Array(7765).map((_, i) => i * 8), 1113, 0);
} catch {}
let textureView40 = texture18.createView({dimension: '2d-array', aspect: 'all'});
try {
renderPassEncoder11.beginOcclusionQuery(47);
} catch {}
try {
renderPassEncoder10.setStencilReference(67);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer4, 36);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer1, 16);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer25, 'uint16', 10, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(103).fill(95), /* required buffer size: 103 */
{offset: 103}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder30 = device0.createCommandEncoder({});
let renderPassEncoder12 = commandEncoder27.beginRenderPass({
  colorAttachments: [{view: textureView38, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet0,
});
let renderBundle1 = renderBundleEncoder7.finish({});
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup1, new Uint32Array(3796), 2_794, 0);
} catch {}
try {
renderBundleEncoder13.draw(29, 15, 34_132_724, 333_101_218);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer1, 188);
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 35,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 123,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 241,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 274,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 353,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 493,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let bindGroup13 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 1, resource: {buffer: buffer6, offset: 0}}, {binding: 0, resource: {buffer: buffer12}}],
});
let commandEncoder31 = device0.createCommandEncoder();
let texture48 = device0.createTexture({
  size: {width: 655, height: 1, depthOrArrayLayers: 41},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView41 = texture4.createView({baseArrayLayer: 2, arrayLayerCount: 4});
let sampler7 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'clamp-to-edge', lodMaxClamp: 94.09});
try {
computePassEncoder3.setBindGroup(0, bindGroup11, new Uint32Array(6282), 1_595, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer29, 8, 72);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup9);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(7, buffer29);
} catch {}
try {
commandEncoder28.copyBufferToTexture({
  /* bytesInLastRow: 146 widthInBlocks: 73 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 386 */
  offset: 386,
  buffer: buffer1,
}, {
  texture: texture40,
  mipLevel: 0,
  origin: {x: 212, y: 0, z: 0},
  aspect: 'all',
}, {width: 73, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 52, new DataView(new ArrayBuffer(55592)), 787, 0);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer4, 12);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture49 = device0.createTexture({
  size: {width: 1310},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder15 = commandEncoder28.beginComputePass();
let renderPassEncoder13 = commandEncoder18.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: 954.0, g: 131.2, b: -260.0, a: -552.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 142054651,
});
try {
computePassEncoder14.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle0, renderBundle1]);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup10);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer1, 'uint32', 128, 123);
} catch {}
try {
renderBundleEncoder8.pushDebugGroup('\u0bfd');
} catch {}
try {
renderBundleEncoder8.popDebugGroup();
} catch {}
try {
commandEncoder30.insertDebugMarker('\u0357');
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Float32Array(1163).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.121)), 15, 0);
} catch {}
let renderBundle2 = renderBundleEncoder13.finish({});
try {
computePassEncoder15.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 28, new Float32Array(3563).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.141)), 1612, 4);
} catch {}
document.body.append(img0);
try {
adapter0.label = '\u62e5\u071b\u{1f82a}\u3168\u{1f613}\udd86\u{1fb9a}\u77e2';
} catch {}
let buffer31 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false});
let commandEncoder32 = device0.createCommandEncoder();
let texture50 = device0.createTexture({
  size: {width: 655},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderPassEncoder14 = commandEncoder30.beginRenderPass({colorAttachments: [{view: textureView15, loadOp: 'load', storeOp: 'store'}]});
try {
renderPassEncoder1.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline1);
} catch {}
let buffer32 = device0.createBuffer({size: 123, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let computePassEncoder16 = commandEncoder32.beginComputePass();
let renderPassEncoder15 = commandEncoder29.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -732.2, g: 84.74, b: 383.1, a: 253.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 208565681,
});
try {
commandEncoder23.pushDebugGroup('\u7bef');
} catch {}
try {
device0.queue.writeBuffer(buffer25, 0, new Float64Array(8356).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/8355)), 4452, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData5 = new ImageData(20, 136);
let texture51 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 18},
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder16 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: 641.9, g: 533.1, b: -536.6, a: -361.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 126310244,
});
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(1538), 27, 0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer24, 'uint16', 2, 2);
} catch {}
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex1',
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 0, shaderLocation: 1},
          {format: 'float16x2', offset: 0, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 0},
          {format: 'uint8x4', offset: 0, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3},
          {format: 'unorm8x4', offset: 0, shaderLocation: 8},
          {format: 'uint16x2', offset: 0, shaderLocation: 5},
          {format: 'uint32', offset: 0, shaderLocation: 4},
          {format: 'float32', offset: 0, shaderLocation: 15},
          {format: 'float32', offset: 0, shaderLocation: 2},
          {format: 'uint8x4', offset: 0, shaderLocation: 13},
          {format: 'unorm8x4', offset: 0, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
document.body.append(canvas0);
try {
commandEncoder25.label = '\u167c\u{1f95b}';
} catch {}
let buffer33 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder33 = device0.createCommandEncoder({});
let renderPassEncoder17 = commandEncoder33.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: -944.3, g: 199.3, b: -965.8, a: 567.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
renderBundleEncoder5.setBindGroup(1, bindGroup6, new Uint32Array(2521), 59, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 40, new DataView(new ArrayBuffer(68396)), 5337, 0);
} catch {}
let autogeneratedBindGroupLayout4 = pipeline5.getBindGroupLayout(0);
let buffer34 = device0.createBuffer({size: 320, usage: GPUBufferUsage.UNIFORM});
let commandEncoder34 = device0.createCommandEncoder({});
let texture52 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder7.setBindGroup(2, bindGroup4, new Uint32Array(609), 436, 0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0, renderBundle1, renderBundle1, renderBundle1, renderBundle2, renderBundle0, renderBundle1, renderBundle1, renderBundle2, renderBundle1]);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer7);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(4156), 1_596, 0);
} catch {}
try {
commandEncoder23.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 49, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture43,
  mipLevel: 1,
  origin: {x: 103, y: 0, z: 0},
  aspect: 'all',
},
{width: 100, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 9, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 20,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
try {
renderBundleEncoder6.setVertexBuffer(0, buffer6, 0, 39);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer25, 0, new Float32Array(12855).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4499)), 2350, 0);
} catch {}
let img1 = await imageWithData(34, 24, '#10101010', '#20202020');
let textureView42 = texture1.createView({dimension: '2d', baseArrayLayer: 4});
let sampler8 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 88.58,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder2.setBindGroup(1, bindGroup5);
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup4);
} catch {}
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
renderPassEncoder8.executeBundles([renderBundle2, renderBundle1]);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer29);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer4, 28);
} catch {}
try {
renderBundleEncoder15.insertDebugMarker('\u06cc');
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(246, 48);
let commandEncoder35 = device0.createCommandEncoder({});
let renderBundle3 = renderBundleEncoder6.finish({});
try {
renderBundleEncoder12.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
let commandEncoder36 = device0.createCommandEncoder({});
try {
renderBundleEncoder10.setVertexBuffer(0, buffer7, 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 4, new Uint32Array(118).map((_, i) => i * 1), 6, 8);
} catch {}
let commandEncoder37 = device0.createCommandEncoder({});
try {
computePassEncoder7.setBindGroup(0, bindGroup12, new Uint32Array(1902), 3, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup3, new Uint32Array(2417), 30, 0);
} catch {}
try {
renderBundleEncoder10.drawIndirect(buffer15, 0);
} catch {}
let gpuCanvasContext1 = offscreenCanvas0.getContext('webgpu');
try {
gpuCanvasContext1.unconfigure();
} catch {}
let renderBundle4 = renderBundleEncoder10.finish({});
try {
renderPassEncoder17.setVertexBuffer(4, buffer6, 0, 4);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(6, buffer6, 36, 30);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
let buffer35 = device0.createBuffer({size: 36, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder38 = device0.createCommandEncoder({});
let texture53 = device0.createTexture({size: {width: 327}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder0.setBindGroup(3, bindGroup0);
} catch {}
let commandEncoder39 = device0.createCommandEncoder();
let textureView43 = texture43.createView({format: 'rg8uint', mipLevelCount: 1});
let computePassEncoder17 = commandEncoder35.beginComputePass();
try {
renderBundleEncoder11.setPipeline(pipeline6);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup9);
} catch {}
try {
renderBundleEncoder11.draw(429, 286, 292_532_668, 970_501_414);
} catch {}
try {
commandEncoder23.popDebugGroup();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 16, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 108, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {binding: 194, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let buffer36 = device0.createBuffer({size: 360, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let commandEncoder40 = device0.createCommandEncoder({});
let textureView44 = texture36.createView({});
let texture54 = device0.createTexture({
  size: {width: 8},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView45 = texture32.createView({baseMipLevel: 0});
try {
renderPassEncoder7.setIndexBuffer(buffer25, 'uint32', 4, 5);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup7);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup9, new Uint32Array(2052), 564, 0);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup3, new Uint32Array(3085), 3_081, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup10);
} catch {}
try {
commandEncoder34.clearBuffer(buffer3);
} catch {}
try {
commandEncoder36.resolveQuerySet(querySet0, 11, 7, buffer0, 0);
} catch {}
let imageData6 = new ImageData(108, 196);
let externalTexture2 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder17.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup12);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup6, new Uint32Array(1168), 170, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer7, 4);
} catch {}
try {
renderBundleEncoder11.setBindGroup(0, bindGroup7, new Uint32Array(277), 27, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer1, 'uint16', 22, 35);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(2, buffer35, 0, 17);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 432 */
  offset: 432,
  rowsPerImage: 129,
  buffer: buffer1,
}, {
  texture: texture14,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let buffer37 = device0.createBuffer({size: 262, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
try {
renderPassEncoder3.setIndexBuffer(buffer24, 'uint16', 0, 6);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer29, 48, 19);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(1, buffer7);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Uint32Array(10562).map((_, i) => i * 3), 352, 0);
} catch {}
let pipeline9 = await promise3;
let buffer38 = device0.createBuffer({size: 128, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView46 = texture35.createView({
  dimension: 'cube',
  format: 'rg8uint',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 2,
  arrayLayerCount: 6,
});
let renderPassEncoder18 = commandEncoder37.beginRenderPass({
  colorAttachments: [{
  view: textureView38,
  clearValue: { r: 712.3, g: 561.9, b: 361.7, a: 912.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder16.setBindGroup(1, bindGroup9, new Uint32Array(1607), 45, 0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup2, new Uint32Array(1497), 293, 0);
} catch {}
try {
renderBundleEncoder11.draw(87, 180, 1_601_871_674, 66_307_207);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
renderBundleEncoder11.drawIndirect(buffer4, 12);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer1, 'uint32', 0, 31);
} catch {}
let buffer39 = device0.createBuffer({
  size: 532,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder41 = device0.createCommandEncoder({});
let sampler9 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 95.61});
try {
computePassEncoder7.setBindGroup(1, bindGroup9, new Uint32Array(3172), 643, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer30, 'uint16', 50, 21);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup8, new Uint32Array(1506), 288, 0);
} catch {}
try {
renderBundleEncoder11.draw(127, 62, 916_360_108, 1_073_916_398);
} catch {}
try {
renderBundleEncoder11.drawIndexedIndirect(buffer4, 0);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline8);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture14,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup14 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 0, resource: {buffer: buffer12}}]});
let commandEncoder42 = device0.createCommandEncoder({});
let texture55 = device0.createTexture({
  size: [12, 12, 1],
  mipLevelCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture56 = device0.createTexture({size: [1310, 1, 5], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
try {
renderPassEncoder9.setIndexBuffer(buffer39, 'uint32', 120, 10);
} catch {}
try {
renderBundleEncoder11.drawIndexedIndirect(buffer4, 104);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline7);
} catch {}
let commandEncoder43 = device0.createCommandEncoder({});
let textureView47 = texture55.createView({dimension: '2d-array', baseMipLevel: 0});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: false});
let renderBundle5 = renderBundleEncoder11.finish({});
try {
computePassEncoder13.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup1, new Uint32Array(3166), 1_057, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 0, new Float16Array(166).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.3051)), 29, 0);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
document.body.prepend(img0);
let bindGroup15 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 0, resource: {buffer: buffer7}}, {binding: 1, resource: {buffer: buffer38}}],
});
let commandEncoder44 = device0.createCommandEncoder({});
let textureView48 = texture8.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 7});
try {
renderPassEncoder15.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer6, 0, 43);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup4);
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d' },
    },
    {binding: 1, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 141, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {
      binding: 168,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
try {
renderPassEncoder11.setBindGroup(2, bindGroup2, []);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer25, 'uint16', 2, 4);
} catch {}
try {
renderBundleEncoder0.setBindGroup(3, bindGroup9);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline8);
} catch {}
try {
commandEncoder34.clearBuffer(buffer0, 8, 16);
} catch {}
try {
device0.queue.label = '\u{1f968}\u066a\ue5d2\u498f\u819d';
} catch {}
let buffer40 = device0.createBuffer({size: 304, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder45 = device0.createCommandEncoder({});
let textureView49 = texture11.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 19});
let externalTexture3 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder6.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer24, 'uint32', 8, 0);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer29, 0);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'});
} catch {}
let pipeline10 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, constants: {}}});
try {
  await promise4;
} catch {}
try {
renderPassEncoder10.insertDebugMarker('\u{1fe5d}');
} catch {}
try {
device0.queue.writeBuffer(buffer37, 44, new Float32Array(8582).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.481)), 2266, 0);
} catch {}
await gc();
let commandEncoder46 = device0.createCommandEncoder({});
let texture57 = device0.createTexture({
  size: [48, 48, 1],
  sampleCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView50 = texture35.createView({dimension: 'cube', mipLevelCount: 1});
let renderPassEncoder19 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView38,
  clearValue: { r: -65.76, g: -178.7, b: 162.4, a: -147.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder18.setPipeline(pipeline7);
} catch {}
let commandEncoder47 = device0.createCommandEncoder();
let computePassEncoder18 = commandEncoder46.beginComputePass();
try {
computePassEncoder1.setBindGroup(0, bindGroup11, new Uint32Array(10000), 763, 0);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer15, 'uint16', 2, 1);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, buffer29, 0, 54);
} catch {}
try {
device0.queue.writeBuffer(buffer37, 96, new Float64Array(8096).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/8093)), 307, 0);
} catch {}
let buffer41 = device0.createBuffer({size: 4, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder48 = device0.createCommandEncoder();
let textureView51 = texture18.createView({baseMipLevel: 0});
try {
renderPassEncoder6.setBindGroup(1, bindGroup2, new Uint32Array(1022), 63, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer24, 'uint16', 0, 3);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer41);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer29, 232, new Float32Array(10470).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7847)), 30, 4);
} catch {}
let bindGroup16 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: {buffer: buffer7, offset: 0}},
    {binding: 0, resource: {buffer: buffer37, size: 76}},
  ],
});
let commandEncoder49 = device0.createCommandEncoder({});
try {
renderPassEncoder9.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer2, 4, 0);
} catch {}
try {
renderBundleEncoder9.drawIndirect(buffer4, 0);
} catch {}
let buffer42 = device0.createBuffer({size: 72, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder9.draw(65, 2, 649_212_914);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(4, buffer41, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(5_981).fill(188), /* required buffer size: 5_981 */
{offset: 179, bytesPerRow: 58, rowsPerImage: 50}, {width: 1, height: 1, depthOrArrayLayers: 3});
} catch {}
let commandEncoder50 = device0.createCommandEncoder({});
let textureView52 = texture42.createView({
  label: '\u219d\u{1fb1a}\u02fa\u2099\uf989\u07ae\u0ba0\uc579\u25c2\u{1fcd5}\ue958',
  dimension: '2d',
  baseArrayLayer: 1,
});
try {
computePassEncoder10.setBindGroup(1, bindGroup4, new Uint32Array(2708), 840, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup6, new Uint32Array(1275), 16, 0);
} catch {}
try {
renderPassEncoder9.draw(37, 1, 1_395_886_478);
} catch {}
try {
  await buffer10.mapAsync(GPUMapMode.READ, 24, 32);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 4, new BigInt64Array(1113).map((_, i) => BigInt(i - 10)), 10, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 2, y: 6, z: 3},
  aspect: 'all',
}, new Uint8Array(120_282).fill(248), /* required buffer size: 120_282 */
{offset: 240, bytesPerRow: 162, rowsPerImage: 82}, {width: 0, height: 4, depthOrArrayLayers: 10});
} catch {}
let pipeline11 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x4deb80e},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment2',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 12,
        attributes: [
          {format: 'unorm8x2', offset: 0, shaderLocation: 12},
          {format: 'uint32', offset: 0, shaderLocation: 2},
          {format: 'unorm16x2', offset: 0, shaderLocation: 1},
          {format: 'uint16x4', offset: 0, shaderLocation: 11},
          {format: 'snorm16x4', offset: 0, shaderLocation: 10},
          {format: 'snorm8x2', offset: 0, shaderLocation: 15},
        ],
      },
      {arrayStride: 4, stepMode: 'instance', attributes: [{format: 'sint8x4', offset: 0, shaderLocation: 9}]},
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
await gc();
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let bindGroup17 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 493, resource: textureView35},
    {binding: 274, resource: externalTexture1},
    {binding: 35, resource: sampler9},
    {binding: 123, resource: textureView8},
    {binding: 353, resource: textureView20},
    {binding: 241, resource: textureView42},
  ],
});
let buffer43 = device0.createBuffer({
  size: 132,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture58 = device0.createTexture({
  size: {width: 655, height: 1, depthOrArrayLayers: 76},
  mipLevelCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderPassEncoder20 = commandEncoder41.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: 860.7, g: -588.5, b: 263.4, a: -305.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder10.setBindGroup(1, bindGroup17, new Uint32Array(1859), 38, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer42, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer42, 8);
} catch {}
try {
renderBundleEncoder9.draw(202, 0, 1_322_821_113);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline1);
} catch {}
try {
buffer1.unmap();
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'pq'} });
try {
renderPassEncoder16.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder9.draw(57, 3, 310_520_415);
} catch {}
try {
renderPassEncoder9.drawIndexed(2, 1, 0, -1_534_996_898, 1);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer40, 8);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder9.draw(242, 0, 1_221_547_938, 0);
} catch {}
try {
renderBundleEncoder9.drawIndirect(buffer42, 0);
} catch {}
try {
buffer7.unmap();
} catch {}
try {
commandEncoder45.resolveQuerySet(querySet0, 23, 3, buffer26, 0);
} catch {}
try {
commandEncoder34.insertDebugMarker('\u{1f6ae}');
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup8, new Uint32Array(285), 54, 0);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder14.setStencilReference(959);
} catch {}
try {
renderPassEncoder9.draw(8, 1, 44_709_480, 1);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline8);
} catch {}
let pipeline12 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'unorm8x2', offset: 270, shaderLocation: 15},
          {format: 'uint32x3', offset: 184, shaderLocation: 2},
          {format: 'sint16x4', offset: 184, shaderLocation: 9},
          {format: 'float32x3', offset: 64, shaderLocation: 10},
          {format: 'uint16x4', offset: 484, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 28,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 0, shaderLocation: 1},
          {format: 'float16x2', offset: 0, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
let autogeneratedBindGroupLayout5 = pipeline0.getBindGroupLayout(0);
let bindGroup18 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 16, resource: externalTexture0},
    {binding: 2, resource: textureView2},
    {binding: 194, resource: externalTexture3},
    {binding: 0, resource: {buffer: buffer34}},
    {binding: 108, resource: sampler2},
  ],
});
let commandEncoder51 = device0.createCommandEncoder({});
let sampler10 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 97.56,
  compare: 'greater',
});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let sampler11 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 97.36,
  compare: 'greater',
});
try {
renderPassEncoder9.executeBundles([renderBundle0, renderBundle1]);
} catch {}
try {
renderPassEncoder8.setStencilReference(1382);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(1, buffer2, 4, 2);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup3, new Uint32Array(3649), 1_508, 0);
} catch {}
try {
commandEncoder40.resolveQuerySet(querySet0, 13, 3, buffer43, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 4, new Uint32Array(23933).map((_, i) => i * 8), 2319, 0);
} catch {}
let commandEncoder52 = device0.createCommandEncoder({});
let textureView53 = texture11.createView({dimension: '2d-array', format: 'rg32sint', mipLevelCount: 1, arrayLayerCount: 7});
try {
computePassEncoder11.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer39, 92);
} catch {}
try {
renderBundleEncoder9.drawIndirect(buffer40, 20);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline8);
} catch {}
try {
buffer29.unmap();
} catch {}
let bindGroup19 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer37, size: 68}}],
});
let texture59 = device0.createTexture({
  size: [163, 1, 1],
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture60 = device0.createTexture({
  size: [163, 1, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView54 = texture23.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder15.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, buffer40);
} catch {}
let textureView55 = texture39.createView({
  label: '\u{1fdb0}\ubdd7\u9f1b\u{1f71d}\u04d9\u2900\u976d\u0fda\ua35f\uae71',
  dimension: '2d-array',
  baseArrayLayer: 0,
});
let texture61 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 47},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder3.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(0, buffer39, 72, 81);
} catch {}
let imageData7 = new ImageData(64, 124);
let textureView56 = texture50.createView({baseArrayLayer: 0});
let externalTexture4 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
renderBundleEncoder16.setIndexBuffer(buffer39, 'uint16', 190, 124);
} catch {}
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: false, stencilReadOnly: true});
try {
renderPassEncoder17.setBindGroup(0, bindGroup14, new Uint32Array(2285), 311, 0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup8, new Uint32Array(201), 19, 0);
} catch {}
try {
renderBundleEncoder3.drawIndirect(buffer40, 92);
} catch {}
let img2 = await imageWithData(28, 2, '#10101010', '#20202020');
let autogeneratedBindGroupLayout6 = pipeline0.getBindGroupLayout(0);
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder12.setPipeline(pipeline8);
} catch {}
let pipeline13 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute1', constants: {}}});
let videoFrame11 = new VideoFrame(imageBitmap0, {timestamp: 0});
let buffer44 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let textureView57 = texture0.createView({mipLevelCount: 1});
let textureView58 = texture60.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder3.setBindGroup(1, bindGroup1);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0, renderBundle4]);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(5, buffer40);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline12);
} catch {}
let commandEncoder53 = device0.createCommandEncoder({});
try {
renderPassEncoder7.setVertexBuffer(0, buffer2, 0, 2);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline8);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(314, 142);
let textureView59 = texture16.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer1, 176);
} catch {}
try {
renderBundleEncoder3.draw(213, 51, 31_972_708, 372_284_704);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(3, buffer35, 0, 6);
} catch {}
try {
commandEncoder39.copyBufferToBuffer(buffer33, 0, buffer44, 4, 0);
} catch {}
let texture62 = device0.createTexture({size: [12, 12, 1], sampleCount: 1, format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
let texture63 = gpuCanvasContext0.getCurrentTexture();
let textureView60 = texture29.createView({});
try {
renderPassEncoder7.drawIndirect(buffer40, 32);
} catch {}
try {
renderBundleEncoder3.draw(73, 284, 1_548_824_834, 622_500_503);
} catch {}
try {
buffer3.unmap();
} catch {}
await gc();
try {
globalThis.someLabel = texture56.label;
} catch {}
let buffer45 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let texture64 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 4},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let renderBundle6 = renderBundleEncoder3.finish({});
let externalTexture5 = device0.importExternalTexture({source: videoFrame9});
try {
renderPassEncoder11.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let promise5 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}});
let buffer46 = device0.createBuffer({size: 292, usage: GPUBufferUsage.UNIFORM});
let texture65 = device0.createTexture({
  size: [8, 8, 13],
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView61 = texture48.createView({dimension: '3d', mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder7.drawIndexed(1, 0, 0, 360_282_584);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer15, 0);
} catch {}
try {
commandEncoder11.clearBuffer(buffer1);
} catch {}
try {
renderBundleEncoder4.insertDebugMarker('\u849f');
} catch {}
try {
device0.queue.writeBuffer(buffer39, 24, new BigInt64Array(3630).map((_, i) => BigInt(i - 0)), 451, 24);
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 0, resource: {buffer: buffer32, size: 68}}],
});
let texture66 = device0.createTexture({
  size: [8, 8, 479],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder11.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup20, new Uint32Array(1335), 79, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 84, new Float32Array(27679).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.518)), 31, 36);
} catch {}
try {
offscreenCanvas1.getContext('webgl2');
} catch {}
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false },
    },
    {binding: 87, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 302,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup21 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: {buffer: buffer30}}, {binding: 0, resource: {buffer: buffer12}}],
});
let buffer47 = device0.createBuffer({
  size: 44,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
computePassEncoder5.setBindGroup(0, bindGroup17, new Uint32Array(454), 10, 0);
} catch {}
try {
renderPassEncoder7.draw(82, 0, 1_613_129_233);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup18, new Uint32Array(907), 109, 0);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder12.pushDebugGroup('\u{1fa52}');
} catch {}
try {
computePassEncoder12.popDebugGroup();
} catch {}
try {
computePassEncoder8.insertDebugMarker('\u{1f852}');
} catch {}
let canvas1 = document.createElement('canvas');
let buffer48 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder54 = device0.createCommandEncoder({label: '\u4ce7\ua8d3\u038f\u{1ff64}\u2bc1\u0385\uf9ef'});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({
  label: '\u1ace\u3252\u13d4\u0121\u219f\u4aa0\u{1fadd}\u92c3',
  colorFormats: ['rg8uint'],
  stencilReadOnly: true,
});
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(171);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer14, 'uint16', 0, 1);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline3);
} catch {}
let arrayBuffer0 = buffer10.getMappedRange(24, 0);
document.body.append(canvas1);
await gc();
let textureView62 = texture23.createView({mipLevelCount: 1});
try {
renderPassEncoder8.setVertexBuffer(0, buffer45, 0, 40);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer49 = device0.createBuffer({size: 488, usage: GPUBufferUsage.STORAGE});
let commandEncoder55 = device0.createCommandEncoder({});
let texture67 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let imageData8 = new ImageData(8, 4);
let bindGroup22 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 20, resource: {buffer: buffer49}},
    {binding: 2, resource: textureView29},
    {binding: 0, resource: textureView57},
    {binding: 9, resource: externalTexture0},
  ],
});
let texture68 = device0.createTexture({
  label: '\u{1f799}\u0b51\u54a0\ufef2\u0083\u0170\u{1ff8a}',
  size: [163, 1, 1],
  mipLevelCount: 3,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView63 = texture38.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderBundleEncoder1.setBindGroup(3, bindGroup10, []);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(6, buffer40);
} catch {}
let bindGroup23 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 241, resource: textureView42},
    {binding: 123, resource: textureView20},
    {binding: 493, resource: textureView52},
    {binding: 274, resource: externalTexture0},
    {binding: 353, resource: textureView57},
    {binding: 35, resource: sampler3},
  ],
});
try {
computePassEncoder15.setBindGroup(1, bindGroup13, new Uint32Array(1104), 53, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
document.body.prepend(img2);
let texture69 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture70 = device0.createTexture({
  size: [327],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder11.setBindGroup(1, bindGroup13, new Uint32Array(2861), 136, 0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup7);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline6);
} catch {}
try {
buffer46.unmap();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
let textureView64 = texture38.createView({arrayLayerCount: 1});
let textureView65 = texture58.createView({dimension: '2d', format: 'rg8uint', baseArrayLayer: 6});
try {
computePassEncoder3.setBindGroup(0, bindGroup17);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(0, buffer6, 28, 2);
} catch {}
let texture71 = device0.createTexture({
  size: [24, 24, 12],
  mipLevelCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView66 = texture26.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 17});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
textureView41.label = '\u7e00\u4489\u0021\u0e96\ud194\u9166';
} catch {}
let commandEncoder56 = device0.createCommandEncoder({});
let texture72 = device0.createTexture({
  size: [6, 6, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture73 = device0.createTexture({
  size: {width: 163},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture6 = device0.importExternalTexture({source: videoFrame10, colorSpace: 'srgb'});
try {
renderPassEncoder14.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder20.draw(225, 0, 151_228_992);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline7);
} catch {}
let arrayBuffer1 = buffer10.getMappedRange(32, 0);
try {
commandEncoder53.resolveQuerySet(querySet0, 19, 4, buffer32, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer40, 12, new DataView(new ArrayBuffer(14352)), 73, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(21).fill(251), /* required buffer size: 21 */
{offset: 21, bytesPerRow: 26}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData9 = new ImageData(8, 92);
let bindGroup24 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 2, resource: textureView17}, {binding: 161, resource: externalTexture1}],
});
let texture74 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 26},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder3.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer1, 36);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer30, 'uint16', 38, 72);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(1, buffer47);
} catch {}
offscreenCanvas0.height = 13;
let commandEncoder57 = device0.createCommandEncoder({});
let commandBuffer1 = commandEncoder12.finish({});
let texture75 = device0.createTexture({size: [1310, 1, 11], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
let textureView67 = texture71.createView({dimension: '2d', format: 'rg8uint', baseArrayLayer: 3});
let sampler12 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 73.84});
try {
computePassEncoder15.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder14.draw(14, 591, 89_200_004, 4_337_801);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer42, 24);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer15, 'uint32', 4, 8);
} catch {}
try {
renderBundleEncoder8.setBindGroup(3, bindGroup23);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup16, new Uint32Array(487), 30, 0);
} catch {}
try {
renderBundleEncoder20.drawIndirect(buffer48, 0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline11);
} catch {}
try {
commandEncoder38.copyBufferToBuffer(buffer47, 0, buffer25, 12, 4);
} catch {}
let img3 = await imageWithData(13, 202, '#10101010', '#20202020');
let buffer50 = device0.createBuffer({size: 263, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let texture76 = device0.createTexture({size: {width: 1310}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder14.end();
} catch {}
try {
renderBundleEncoder20.drawIndirect(buffer4, 4);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer39, 'uint16', 22, 6);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer2, 0, 0);
} catch {}
let arrayBuffer2 = buffer10.getMappedRange(40, 4);
try {
commandEncoder51.copyBufferToBuffer(buffer33, 4, buffer3, 44, 4);
} catch {}
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d' },
    },
    {binding: 1, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 141, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {
      binding: 168,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let renderBundle7 = renderBundleEncoder20.finish();
try {
computePassEncoder3.setBindGroup(3, bindGroup15, new Uint32Array(1335), 278, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer43, 'uint16', 10, 40);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline12);
} catch {}
let arrayBuffer3 = buffer10.getMappedRange(48, 0);
try {
commandEncoder38.insertDebugMarker('\ub6f0');
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Uint32Array(6745).map((_, i) => i * 3), 1131, 0);
} catch {}
let bindGroup25 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer49}}]});
let buffer51 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
try {
computePassEncoder9.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle3, renderBundle7, renderBundle7, renderBundle7, renderBundle3]);
} catch {}
try {
renderBundleEncoder18.drawIndirect(buffer40, 104);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
document.body.prepend(img1);
let renderBundle8 = renderBundleEncoder18.finish({});
try {
renderPassEncoder2.setVertexBuffer(0, buffer47);
} catch {}
try {
renderBundleEncoder8.drawIndirect(buffer50, 184);
} catch {}
try {
buffer37.unmap();
} catch {}
try {
commandEncoder48.copyBufferToBuffer(buffer33, 4, buffer47, 0, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let buffer52 = device0.createBuffer({size: 256, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder58 = device0.createCommandEncoder();
let texture77 = device0.createTexture({
  size: [24, 24, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder8.drawIndirect(buffer15, 0);
} catch {}
let bindGroup26 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 9, resource: externalTexture5},
    {binding: 20, resource: {buffer: buffer49}},
    {binding: 0, resource: textureView20},
    {binding: 2, resource: textureView6},
  ],
});
let commandEncoder59 = device0.createCommandEncoder({});
let texture78 = gpuCanvasContext0.getCurrentTexture();
try {
renderBundleEncoder21.setBindGroup(0, bindGroup13, new Uint32Array(1784), 141, 0);
} catch {}
try {
renderBundleEncoder8.drawIndirect(buffer1, 64);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 36, new DataView(new ArrayBuffer(8448)), 122, 4);
} catch {}
let commandEncoder60 = device0.createCommandEncoder({});
let texture79 = device0.createTexture({
  label: '\u939a\u77e6\ufc73\u06bf\ud548\u2477\u{1ff04}\u{1fab1}\u0872\u{1fed4}',
  size: [48],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder19 = commandEncoder52.beginComputePass();
let sampler13 = device0.createSampler({addressModeW: 'clamp-to-edge', lodMaxClamp: 86.43});
try {
computePassEncoder19.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup22);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle8, renderBundle5]);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer52, 'uint32', 12, 46);
} catch {}
try {
renderBundleEncoder8.draw(201, 0, 421_422_422);
} catch {}
try {
buffer39.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let buffer53 = device0.createBuffer({size: 8, usage: GPUBufferUsage.INDIRECT});
let texture80 = device0.createTexture({
  size: {width: 24, height: 24, depthOrArrayLayers: 125},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView68 = texture68.createView({format: 'rg8uint', baseMipLevel: 1, mipLevelCount: 1});
try {
renderPassEncoder17.setBindGroup(3, bindGroup24, new Uint32Array(60), 12, 0);
} catch {}
let commandEncoder61 = device0.createCommandEncoder();
let texture81 = device0.createTexture({size: {width: 163}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
let renderBundle9 = renderBundleEncoder8.finish({});
try {
computePassEncoder18.setBindGroup(0, bindGroup4, new Uint32Array(3351), 401, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer39, 0, 145);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup9);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
commandEncoder48.resolveQuerySet(querySet0, 53, 0, buffer2, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
globalThis.someLabel = texture71.label;
} catch {}
let commandEncoder62 = device0.createCommandEncoder();
let texture82 = device0.createTexture({size: {width: 163}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
let renderBundle10 = renderBundleEncoder9.finish({});
let externalTexture7 = device0.importExternalTexture({source: videoFrame11});
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer30, 'uint16', 8, 43);
} catch {}
let textureView69 = texture9.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder12.setVertexBuffer(6, buffer40);
} catch {}
offscreenCanvas0.height = 624;
let imageData10 = new ImageData(8, 72);
let texture83 = device0.createTexture({
  size: [48, 48, 1],
  dimension: '2d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder4.setBindGroup(2, bindGroup0, new Uint32Array(2413), 82, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup3, new Uint32Array(305), 5, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(1, buffer47, 0);
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

alias vec3b = vec3<bool>;

fn unconst_u32(v: u32) -> u32 { return v; }

fn unconst_bool(v: bool) -> bool { return v; }

fn unconst_f32(v: f32) -> f32 { return v; }

@group(0) @binding(20) var<storage, read> buffer54: array<array<vec4i, 24>>;

fn unconst_i32(v: i32) -> i32 { return v; }

struct VertexInput7 {
  @location(6) location_6: vec4f,
}

struct VertexInput5 {
  @location(0) location_0: vec4f,
}

struct VertexOutput1 {
  @location(15) @interpolate(flat, first) location_15: vec4f,
  @location(13) location_13: vec2f,
  @location(1) location_1: i32,
  @builtin(position) position: vec4f,
  @location(3) @interpolate(flat, centroid) location_3: vec2h,
  @location(2) location_2: i32,
  @location(10) location_10: vec2f,
  @location(9) @interpolate(flat, centroid) location_9: vec4f,
  @location(5) @interpolate(linear, either) location_5: f16,
}

struct T0 {
  @align(16) f0: array<u32>,
}

var<workgroup> vw2: atomic<i32>;

struct FragmentInput12 {
  @location(3) @interpolate(flat, centroid) location_3: vec2h,
}

struct FragmentOutput5 {
  @location(5) location_5: vec4u,
  @location(0) location_0: vec4u,
}

@group(0) @binding(9) var et1: texture_external;

@group(0) @binding(0) var tex4: texture_2d<f32>;

fn unconst_f16(v: f16) -> f16 { return v; }

struct VertexInput8 {
  @location(10) location_10: vec2h,
}

struct VertexInput6 {
  @location(13) location_13: vec2i,
  @location(11) @interpolate(flat) location_11: vec2u,
  @location(15) location_15: vec4u,
  @location(4) location_4: vec2f,
}

struct VertexInput9 {
  @location(1) location_1: vec4h,
}

/* used global variables: buffer54, et1, tex4 */
@vertex
fn vertex3(@location(5) @interpolate(flat) location_5: vec4u, a1: VertexInput5, a2: VertexInput6, a3: VertexInput7, @location(9) @interpolate(flat, centroid) location_9: vec2f, @location(8) @interpolate(perspective, sample) location_8: vec4f, a6: VertexInput8, @location(12) @interpolate(flat, either) location_12: vec2i, a8: VertexInput9, @location(14) location_14: i32, @location(3) @interpolate(linear, first) location_3: vec2f, @location(2) location_2: f16) -> VertexOutput1 {
  var out: VertexOutput1;
  let ptr19: ptr<function, i32> = &out.location_2;
  loop {
  let ptr20: ptr<function, vec4f> = &out.location_15;
  break;
}
  var vf23: i32 = (*&buffer54)[unconst_u32(94399815)][unconst_u32(77602174)][unconst_u32(712243389)];
  out.location_10 *= vec2f(a2.location_4[unconst_u32(445507837)]);
  let vf24: vec4f = a1.location_0;
  out.position = vec4f(a8.location_1.wzyw.yywy.xwzy.raba.yzww);
  out.position -= textureLoad(tex4, vec2i(unconst_i32(584811885), unconst_i32(103406886)), unconst_i32(959836955));
  out.location_1 &= vec2i(textureDimensions(et1).rr)[1];
  return out;
  _ = tex4;
  _ = et1;
  _ = buffer54;
}

/* zero global variables used */
@fragment
fn fragment5(@location(9) @interpolate(flat, first) location_9: vec4f, @location(2) @interpolate(flat) location_2: i32, @location(5) @interpolate(linear) location_5: f16, @location(10) location_10: vec2f, a4: FragmentInput12) -> FragmentOutput5 {
  var out: FragmentOutput5;
  let vf25: vec3f = asinh(vec3f(unconst_f32(0.04990), unconst_f32(0.04810), unconst_f32(0.1406)));
  return out;
}

/* used global variables: buffer54 */
@compute @workgroup_size(1, 2, 1)
fn compute5(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u) {
  let ptr21: ptr<workgroup, atomic<i32>> = &vw2;
  var vf26: i32 = atomicExchange(&(*&vw2), unconst_i32(177160125));
  let ptr22: ptr<storage, vec4i, read> = &buffer54[unconst_u32(4189025527)][num_workgroups[2]];
  var vf27: u32 = pack4x8snorm(vec4f(unconst_f32(0.1328), unconst_f32(0.03754e-39), unconst_f32(-0.04876), unconst_f32(0.1057)));
  var vf28: u32 = local_invocation_id[unconst_u32(430560445)];
  let ptr23: ptr<function, u32> = &vf27;
  _ = buffer54;
}`,
});
try {
renderBundleEncoder22.setBindGroup(1, bindGroup12);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline1);
} catch {}
let autogeneratedBindGroupLayout7 = pipeline4.getBindGroupLayout(0);
let bindGroup27 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer49}}]});
let buffer55 = device0.createBuffer({size: 252, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let externalTexture8 = device0.importExternalTexture({source: videoFrame11, colorSpace: 'display-p3'});
try {
renderPassEncoder2.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer40, 0, 49);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer24, 'uint16', 8, 0);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(4, buffer2, 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 0, new Float32Array(7617).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8342)), 2043, 20);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(131); };
} catch {}
document.body.prepend(canvas1);
let imageData11 = new ImageData(8, 52);
let commandEncoder63 = device0.createCommandEncoder();
let textureView70 = texture21.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1});
let computePassEncoder20 = commandEncoder44.beginComputePass();
try {
computePassEncoder20.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder0.draw(40, 292, 1_172_000_293, 942_933_413);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer50, 64);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(5, buffer35, 0, 2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(9).fill(208), /* required buffer size: 9 */
{offset: 9, rowsPerImage: 21}, {width: 163, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte240m', transfer: 'gamma22curve'} });
let bindGroup28 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer49}}]});
let commandEncoder64 = device0.createCommandEncoder({});
let texture84 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  dimension: '2d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView71 = texture48.createView({mipLevelCount: 1});
try {
renderPassEncoder18.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer4, 20);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer25, 'uint16', 0, 15);
} catch {}
let pipeline14 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment2',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 140,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x4', offset: 44, shaderLocation: 2},
          {format: 'snorm8x4', offset: 0, shaderLocation: 15},
          {format: 'uint8x2', offset: 6, shaderLocation: 11},
          {format: 'unorm8x2', offset: 2, shaderLocation: 10},
          {format: 'sint32x2', offset: 0, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 72,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 16, shaderLocation: 1},
          {format: 'snorm16x4', offset: 0, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', cullMode: 'back', unclippedDepth: false},
});
let buffer56 = device0.createBuffer({size: 25172, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false});
let texture85 = device0.createTexture({
  size: [6, 6, 1],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle11 = renderBundleEncoder0.finish({});
try {
computePassEncoder0.setBindGroup(1, bindGroup28, new Uint32Array(4045), 340, 0);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer24, 'uint16', 8, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Float64Array(16032).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/16027)), 6579, 0);
} catch {}
let bindGroup29 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer49}}]});
let sampler14 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 69.47,
});
try {
renderPassEncoder19.setBindGroup(1, bindGroup22, []);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup21, new Uint32Array(785), 453, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer14, 'uint32', 0, 2);
} catch {}
let commandEncoder65 = device0.createCommandEncoder({});
let renderPassEncoder21 = commandEncoder40.beginRenderPass({
  colorAttachments: [{
  view: textureView24,
  depthSlice: 9,
  clearValue: { r: 530.4, g: 645.1, b: -652.6, a: 12.59, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 90082926,
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup22);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer52, 'uint16', 2, 32);
} catch {}
document.body.prepend(img3);
let texture86 = device0.createTexture({
  size: {width: 12},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder16.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup25);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup18, new Uint32Array(2174), 102, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 356, new Float32Array(7657).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4404)), 461, 20);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(38); };
} catch {}
let commandEncoder66 = device0.createCommandEncoder({});
let textureView72 = texture72.createView({});
try {
renderPassEncoder6.executeBundles([renderBundle0, renderBundle2]);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer39, 'uint16', 292, 50);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup7, new Uint32Array(486), 216, 0);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(3, buffer55, 188);
} catch {}
try {
commandEncoder51.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 256 */
  offset: 240,
  buffer: buffer1,
}, {
  texture: texture84,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
document.body.append(canvas0);
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte432', transfer: 'hlg'} });
try {
adapter0.label = '\u{1fe33}\u1d58\u06cc\u020d\u165b';
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let textureView73 = texture29.createView({aspect: 'all', baseMipLevel: 0});
try {
renderPassEncoder3.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer37, 8, new Float32Array(13059).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.136)), 3247, 8);
} catch {}
let bindGroup30 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 20, resource: {buffer: buffer49}}]});
let buffer57 = device0.createBuffer({size: 15, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let textureView74 = texture2.createView({});
let gpuCanvasContext2 = canvas1.getContext('webgpu');
offscreenCanvas1.height = 931;
let texture87 = device0.createTexture({
  size: [327, 1, 7],
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder18.setBindGroup(1, bindGroup19);
} catch {}
try {
commandEncoder61.copyTextureToBuffer({
  texture: texture70,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2002 */
  offset: 2002,
  buffer: buffer56,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 56, new DataView(new ArrayBuffer(6362)), 938, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let texture88 = device0.createTexture({
  size: {width: 24},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder19.setIndexBuffer(buffer25, 'uint16', 8, 1);
} catch {}
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'film', transfer: 'gamma28curve'} });
let texture89 = device0.createTexture({
  size: [12, 12, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView75 = texture67.createView({});
try {
renderPassEncoder10.setIndexBuffer(buffer15, 'uint32', 8, 0);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline12);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let autogeneratedBindGroupLayout8 = pipeline14.getBindGroupLayout(1);
let bindGroup31 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 161, resource: externalTexture5}, {binding: 2, resource: textureView8}],
});
let commandEncoder68 = device0.createCommandEncoder({});
let texture90 = device0.createTexture({
  size: {width: 24, height: 24, depthOrArrayLayers: 2},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderBundleEncoder15.setIndexBuffer(buffer1, 'uint16', 32, 11);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 250 */
  offset: 250,
  bytesPerRow: 9216,
  buffer: buffer55,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 5},
  aspect: 'all',
}, {width: 2, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder20.pushDebugGroup('\uc2fe');
} catch {}
try {
device0.queue.writeBuffer(buffer1, 264, new DataView(new ArrayBuffer(15172)), 162, 16);
} catch {}
let bindGroup32 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 16, resource: externalTexture1},
    {binding: 108, resource: sampler0},
    {binding: 0, resource: {buffer: buffer46}},
    {binding: 2, resource: textureView14},
    {binding: 194, resource: externalTexture7},
  ],
});
try {
renderPassEncoder20.setBindGroup(0, bindGroup32, new Uint32Array(449), 89, 0);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline7);
} catch {}
let buffer58 = device0.createBuffer({size: 40, usage: GPUBufferUsage.QUERY_RESOLVE});
let textureView76 = texture18.createView({arrayLayerCount: 1});
try {
computePassEncoder10.setBindGroup(0, bindGroup17);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup19, []);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer15, 'uint32', 0, 3);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup1, new Uint32Array(823), 7, 0);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(1, buffer45, 0, 19);
} catch {}
try {
commandEncoder67.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture73,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let commandEncoder69 = device0.createCommandEncoder({});
let sampler15 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 91.34,
  maxAnisotropy: 1,
});
try {
renderBundleEncoder21.setVertexBuffer(4, buffer29, 28, 119);
} catch {}
try {
buffer46.unmap();
} catch {}
let texture91 = device0.createTexture({
  size: {width: 163},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder1.setIndexBuffer(buffer52, 'uint16', 34, 2);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline11);
} catch {}
try {
buffer29.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
try {
renderPassEncoder10.setBlendConstant({ r: -661.5, g: 358.9, b: -843.9, a: -664.9, });
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer15, 'uint16', 4, 2);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline7);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 130, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(163).fill(30), /* required buffer size: 163 */
{offset: 163, bytesPerRow: 386}, {width: 180, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder70 = device0.createCommandEncoder({});
try {
renderPassEncoder1.setBindGroup(1, bindGroup26, new Uint32Array(959), 28, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer2);
} catch {}
try {
renderBundleEncoder23.setBindGroup(3, bindGroup10);
} catch {}
try {
commandEncoder49.insertDebugMarker('\u{1f8cd}');
} catch {}
try {
globalThis.someLabel = textureView63.label;
} catch {}
let bindGroup33 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 20, resource: {buffer: buffer49, offset: 0}}],
});
let texture92 = device0.createTexture({
  size: [327, 1, 28],
  mipLevelCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder17.setBindGroup(3, bindGroup21);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup34 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 2, resource: textureView14},
    {binding: 194, resource: externalTexture3},
    {binding: 108, resource: sampler2},
    {binding: 16, resource: externalTexture3},
    {binding: 0, resource: {buffer: buffer34}},
  ],
});
let buffer59 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
renderPassEncoder10.setBindGroup(2, bindGroup31, new Uint32Array(1770), 381, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer47, 'uint16', 6, 5);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer55, 'uint32', 4, 29);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
commandEncoder51.copyTextureToBuffer({
  texture: texture65,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 84 */
  offset: 84,
  bytesPerRow: 0,
  rowsPerImage: 202,
  buffer: buffer56,
}, {width: 0, height: 0, depthOrArrayLayers: 3});
} catch {}
try {
computePassEncoder20.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer25, 0, new Uint32Array(80).map((_, i) => i * 1), 24, 0);
} catch {}
let pipeline15 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule3, entryPoint: 'fragment4', targets: [{format: 'rg8uint'}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 48,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32x4', offset: 4, shaderLocation: 9},
          {format: 'float16x2', offset: 4, shaderLocation: 15},
          {format: 'uint32', offset: 0, shaderLocation: 2},
          {format: 'unorm16x2', offset: 12, shaderLocation: 1},
          {format: 'float32x2', offset: 4, shaderLocation: 10},
          {format: 'uint32x2', offset: 0, shaderLocation: 11},
        ],
      },
      {arrayStride: 24, attributes: [{format: 'unorm16x4', offset: 0, shaderLocation: 12}]},
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'none', unclippedDepth: true},
});
let commandEncoder71 = device0.createCommandEncoder({});
try {
computePassEncoder4.setBindGroup(1, bindGroup30);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer43, 'uint16', 54, 2);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(6, buffer55, 0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder48.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 1},
  aspect: 'all',
},
{
  texture: texture60,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer60 = device0.createBuffer({
  size: 572,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 384});
let texture93 = device0.createTexture({
  size: {width: 327},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView77 = texture15.createView({});
try {
renderPassEncoder19.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline12);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 124, new DataView(new Uint8Array(3609).map((_, i) => i).buffer), 1201, 56);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let textureView78 = texture54.createView({label: '\u0bad\u01ff\u{1ffe1}\u{1ffc7}\ue0d2\u0cbe\u0b09\u61ee\u{1f9b3}'});
try {
renderPassEncoder15.setVertexBuffer(2, buffer40);
} catch {}
try {
commandEncoder42.copyTextureToBuffer({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 3, y: 7, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 112 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1008 */
  offset: 1008,
  bytesPerRow: 20480,
  buffer: buffer56,
}, {width: 7, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer25, 8, new Uint32Array(4077).map((_, i) => i * 9), 9, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture81,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(196).fill(172), /* required buffer size: 196 */
{offset: 196, bytesPerRow: 12, rowsPerImage: 24}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture94 = device0.createTexture({
  size: [6, 6, 1],
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder8.setBindGroup(3, bindGroup31, new Uint32Array(1417), 279, 0);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(5, buffer55, 20, 39);
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let texture95 = device0.createTexture({size: {width: 655}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
let textureView79 = texture46.createView({aspect: 'all'});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 2,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(803).fill(140), /* required buffer size: 803 */
{offset: 803}, {width: 32, height: 0, depthOrArrayLayers: 1});
} catch {}
let imageBitmap1 = await createImageBitmap(imageData0);
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let buffer61 = device0.createBuffer({size: 152, usage: GPUBufferUsage.INDIRECT});
let commandEncoder72 = device0.createCommandEncoder({});
let externalTexture9 = device0.importExternalTexture({source: videoFrame6});
try {
renderPassEncoder3.setBindGroup(3, bindGroup9);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(161);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup14);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup16, new Uint32Array(465), 82, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline14);
} catch {}
try {
commandEncoder70.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture41,
  mipLevel: 0,
  origin: {x: 13, y: 9, z: 14},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup35 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 16, resource: externalTexture6},
    {binding: 108, resource: sampler15},
    {binding: 194, resource: externalTexture6},
    {binding: 0, resource: {buffer: buffer50, size: 242}},
    {binding: 2, resource: textureView14},
  ],
});
let commandEncoder73 = device0.createCommandEncoder();
let commandBuffer2 = commandEncoder11.finish();
let textureView80 = texture46.createView({format: 'rgb10a2unorm', arrayLayerCount: 1});
try {
computePassEncoder8.setBindGroup(0, bindGroup8, new Uint32Array(508), 122, 0);
} catch {}
try {
renderBundleEncoder21.setBindGroup(3, bindGroup10);
} catch {}
try {
buffer56.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter0.label = '\u8abd\u67a8\u3864\u0528\u{1fa9b}\u{1f6f7}';
} catch {}
let bindGroup36 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer6}}]});
let commandEncoder74 = device0.createCommandEncoder({});
let texture96 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 150},
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView81 = texture61.createView({mipLevelCount: 1, arrayLayerCount: 3});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
try {
renderPassEncoder8.setIndexBuffer(buffer39, 'uint16', 4, 172);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(6, buffer57, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer39, 60, new Uint32Array(719).map((_, i) => i * 8), 23, 36);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.append(img1);
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470m', transfer: 'bt709'} });
let commandBuffer3 = commandEncoder30.finish();
let textureView82 = texture96.createView({});
let textureView83 = texture14.createView({mipLevelCount: 1, baseArrayLayer: 6});
let renderPassEncoder22 = commandEncoder73.beginRenderPass({
  colorAttachments: [{
  view: textureView51,
  clearValue: { r: 560.0, g: -42.65, b: -410.3, a: -276.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderBundleEncoder19.setIndexBuffer(buffer25, 'uint16', 6, 12);
} catch {}
try {
commandEncoder66.clearBuffer(buffer37, 16, 8);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 4, new Float32Array(4648).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.074)), 1533, 20);
} catch {}
let autogeneratedBindGroupLayout9 = pipeline3.getBindGroupLayout(0);
let commandEncoder75 = device0.createCommandEncoder({});
let texture97 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 21},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let imageData12 = new ImageData(64, 40);
let commandEncoder76 = device0.createCommandEncoder();
let texture98 = device0.createTexture({
  size: [1310, 1, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture99 = device0.createTexture({
  size: [24],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder16.setVertexBuffer(0, buffer57, 0, 1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder47.resolveQuerySet(querySet1, 41, 15, buffer36, 0);
} catch {}
try {
device0.queue.submit([commandBuffer2, commandBuffer3]);
} catch {}
let pipeline16 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 1820, shaderLocation: 10},
          {format: 'float32', offset: 24, shaderLocation: 1},
          {format: 'sint32x4', offset: 1212, shaderLocation: 9},
          {format: 'unorm16x4', offset: 20, shaderLocation: 15},
          {format: 'float32x2', offset: 56, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 156,
        attributes: [
          {format: 'uint32x4', offset: 20, shaderLocation: 2},
          {format: 'uint32x4', offset: 20, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
let commandEncoder77 = device0.createCommandEncoder();
let textureView84 = texture98.createView({dimension: '2d', arrayLayerCount: 1});
try {
computePassEncoder3.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(6, buffer7, 20);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
let bindGroup37 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer60}}],
});
let buffer62 = device0.createBuffer({
  label: '\u7781\u6243\u78d9\u89a8\u0caf\u3046\u0d00\u07c9',
  size: 320,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let texture100 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder10.executeBundles([renderBundle10, renderBundle10]);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline12);
} catch {}
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let texture101 = device0.createTexture({
  size: [8, 8, 178],
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture102 = device0.createTexture({
  size: [8, 8, 13],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView85 = texture38.createView({aspect: 'all'});
try {
renderPassEncoder3.setVertexBuffer(0, buffer2);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup1, new Uint32Array(2100), 53, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer40, 152, new DataView(new ArrayBuffer(12152)), 1601, 4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(img0);
let buffer63 = device0.createBuffer({size: 33, usage: GPUBufferUsage.INDIRECT});
let commandEncoder78 = device0.createCommandEncoder({});
let textureView86 = texture101.createView({});
let textureView87 = texture87.createView({arrayLayerCount: 1});
try {
renderBundleEncoder14.setIndexBuffer(buffer55, 'uint16', 14, 15);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
  await buffer59.mapAsync(GPUMapMode.WRITE, 0, 12);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let texture103 = device0.createTexture({
  size: {width: 12},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer56, 2_372, new Float64Array(23519).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/23514)), 11282, 560);
} catch {}
try {
  await promise7;
} catch {}
let bindGroup38 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 108, resource: sampler8},
    {binding: 194, resource: externalTexture7},
    {binding: 2, resource: textureView19},
    {binding: 0, resource: {buffer: buffer62, offset: 0}},
    {binding: 16, resource: externalTexture5},
  ],
});
let commandEncoder79 = device0.createCommandEncoder({});
let texture104 = device0.createTexture({
  size: {width: 570, height: 318, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'astc-10x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder22.setPipeline(pipeline12);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer25, 8, new Uint32Array(2395).map((_, i) => i * 9), 161, 0);
} catch {}
try {
  await promise6;
} catch {}
let buffer64 = device0.createBuffer({size: 1332, usage: GPUBufferUsage.QUERY_RESOLVE});
let textureView88 = texture75.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 2});
try {
renderPassEncoder10.setBindGroup(1, bindGroup9);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline12);
} catch {}
let arrayBuffer4 = buffer59.getMappedRange(0, 0);
let promise8 = device0.queue.onSubmittedWorkDone();
let pipeline17 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 96,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 0, shaderLocation: 2},
          {format: 'float32x2', offset: 8, shaderLocation: 15},
          {format: 'float32', offset: 40, shaderLocation: 1},
          {format: 'uint32', offset: 0, shaderLocation: 11},
          {format: 'float32x4', offset: 0, shaderLocation: 12},
          {format: 'sint8x2', offset: 22, shaderLocation: 9},
          {format: 'snorm8x2', offset: 38, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front', unclippedDepth: true},
});
let shaderModule5 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

requires readonly_and_readwrite_storage_textures;

enable f16;

diagnostic(info, xyz);

fn unconst_bool(v: bool) -> bool { return v; }

struct T2 {
  @size(128) f0: T1,
}

fn unconst_i32(v: i32) -> i32 { return v; }

struct T6 {
  @size(16) f0: atomic<u32>,
}

struct T0 {
  @align(32) @size(1920) f0: array<array<vec2<bool>, 2>, 4>,
  @size(160) f1: array<array<array<bool, 1>, 1>, 10>,
}

struct T7 {
  f0: array<T6>,
}

struct T10 {
  @size(32) f0: vec2f,
  @size(16) f1: array<atomic<u32>, 1>,
  f2: array<u32>,
}

fn unconst_f16(v: f16) -> f16 { return v; }

override override5: f16;

var<workgroup> vw4: atomic<u32>;

@id(33369) override override8: u32;

override override4: i32 = 137073502;

struct FragmentOutput6 {
  @location(0) @interpolate(flat, either) location_0: vec2u,
  @location(2) location_2: vec4i,
}

struct T1 {
  @size(16) f0: u32,
}

var<workgroup> vw5: atomic<i32>;

struct FragmentInput13 {
  @builtin(position) position: vec4f,
}

struct T5 {
  @align(16) @size(256) f0: T1,
  @size(112) f1: T1,
}

@id(33776) override override7: f32;

@group(1) @binding(9) var<storage, read_write> buffer67: array<array<array<array<f16, 47>, 4>, 2>, 4>;

struct T8 {
  @size(128) f0: vec2<bool>,
}

override override9 = -0.04137e-7;

struct T9 {
  @size(64) f0: vec4u,
}

fn unconst_u32(v: u32) -> u32 { return v; }

@id(9399) override override6: u32 = (38595380 % 103) + 1;

fn unconst_f32(v: f32) -> f32 { return v; }

var<workgroup> vw3: array<f16, 1>;

struct T3 {
  @size(58) f0: T1,
}

struct T4 {
  @align(32) f0: array<atomic<u32>>,
}

/* used global variables: buffer67 */
@fragment
fn fragment6(a0: FragmentInput13, @builtin(sample_mask) sample_mask: u32) -> FragmentOutput6 {
  var out: FragmentOutput6;
  let ptr24: ptr<storage, array<array<f16, 47>, 4>, read_write> = &buffer67[unconst_u32(13726133)][1];
  let ptr25: ptr<storage, array<array<f16, 47>, 4>, read_write> = &(*&buffer67)[unconst_u32(842438303)][1];
  return out;
  _ = buffer67;
}`,
});
try {
renderPassEncoder11.setIndexBuffer(buffer1, 'uint16', 96, 7);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(1, buffer51, 0);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(3, buffer39, 0, 171);
} catch {}
try {
buffer47.unmap();
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'hlg'} });
let buffer72 = device0.createBuffer({size: 41724, usage: GPUBufferUsage.UNIFORM});
let commandEncoder80 = device0.createCommandEncoder({});
let textureView89 = texture7.createView({baseMipLevel: 0});
try {
renderPassEncoder6.setBindGroup(1, bindGroup30, new Uint32Array(1885), 528, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer43, 'uint32', 60, 9);
} catch {}
try {
renderBundleEncoder25.setBindGroup(2, bindGroup4, new Uint32Array(313), 46, 0);
} catch {}
let arrayBuffer5 = buffer59.getMappedRange(8, 0);
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup39 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer60}}]});
let texture105 = device0.createTexture({
  size: [48, 48, 150],
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder15.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer35, 4, 1);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup34, new Uint32Array(57), 8, 0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline17);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
buffer61.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer29, 24, new Uint32Array(4870).map((_, i) => i * 9), 147, 24);
} catch {}
let buffer73 = device0.createBuffer({size: 104, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let textureView90 = texture105.createView({});
try {
renderPassEncoder22.setBindGroup(1, bindGroup37);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 16, new Uint32Array(85).map((_, i) => i * 10), 5, 0);
} catch {}
let bindGroup40 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 20, resource: {buffer: buffer49}}]});
let commandEncoder81 = device0.createCommandEncoder();
let textureView91 = texture105.createView({dimension: '3d'});
let textureView92 = texture5.createView({aspect: 'all', baseArrayLayer: 0});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
try {
renderPassEncoder6.setStencilReference(1186);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer35);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup10, new Uint32Array(1382), 367, 0);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline1);
} catch {}
try {
buffer73.destroy();
} catch {}
try {
commandEncoder66.resolveQuerySet(querySet0, 19, 14, buffer11, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let textureView93 = texture69.createView({baseArrayLayer: 1, arrayLayerCount: 2});
try {
computePassEncoder11.setBindGroup(0, bindGroup34, new Uint32Array(2581), 363, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup8, new Uint32Array(2243), 153, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer14, 'uint16', 6, 0);
} catch {}
try {
renderBundleEncoder25.setBindGroup(1, bindGroup37);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer52, 'uint32', 52, 8);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(3, buffer55, 0, 70);
} catch {}
try {
buffer39.unmap();
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let pipeline18 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x1e2b5d42},
  fragment: {module: shaderModule5, constants: {}, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA}]},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 8,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm8x4', offset: 0, shaderLocation: 0},
          {format: 'uint16x4', offset: 0, shaderLocation: 11},
          {format: 'sint16x2', offset: 0, shaderLocation: 12},
          {format: 'sint16x4', offset: 0, shaderLocation: 13},
          {format: 'float32x2', offset: 0, shaderLocation: 3},
          {format: 'sint16x4', offset: 0, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10},
          {format: 'unorm8x2', offset: 0, shaderLocation: 2},
          {format: 'unorm16x4', offset: 0, shaderLocation: 9},
          {format: 'uint32x2', offset: 0, shaderLocation: 5},
          {format: 'unorm16x2', offset: 0, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 264, shaderLocation: 8},
          {format: 'unorm16x4', offset: 332, shaderLocation: 1},
          {format: 'unorm16x2', offset: 40, shaderLocation: 4},
          {format: 'uint16x2', offset: 716, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer74 = device0.createBuffer({label: '\uebec\u1f4f\u6ca0\u83a1\u00eb\ub212', size: 47, usage: GPUBufferUsage.INDEX});
let textureView94 = texture101.createView({});
let texture106 = device0.createTexture({
  size: {width: 6},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder11.executeBundles([renderBundle0, renderBundle8, renderBundle8, renderBundle8, renderBundle4]);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer45, 0, 0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(0, buffer55);
} catch {}
try {
buffer45.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer3, 4, new Uint16Array(7132).map((_, i) => i + 3), 906, 4);
} catch {}
let imageData13 = new ImageData(20, 12);
let commandEncoder82 = device0.createCommandEncoder();
let texture107 = device0.createTexture({
  size: [163, 1, 1],
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder13.setVertexBuffer(0, buffer57, 4, 1);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup3);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(1, buffer40);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(25); };
} catch {}
let commandEncoder83 = device0.createCommandEncoder();
let renderPassEncoder23 = commandEncoder57.beginRenderPass({
  colorAttachments: [{
  view: textureView66,
  clearValue: { r: -138.8, g: -310.4, b: -655.1, a: 286.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder12.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder16.drawIndexed(21, 0, 20, -71_628_681);
} catch {}
try {
renderBundleEncoder16.drawIndexedIndirect(buffer1, 24);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer43, 'uint16', 6, 6);
} catch {}
try {
buffer63.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise9;
} catch {}
let commandEncoder84 = device0.createCommandEncoder({});
let texture108 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder24 = commandEncoder65.beginRenderPass({
  colorAttachments: [{
  view: textureView73,
  depthSlice: 14,
  clearValue: { r: 884.5, g: -518.6, b: 793.1, a: 138.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder12.drawIndexedIndirect(buffer62, 140);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer52, 4);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer47, 'uint16', 14, 2);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer39);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup16);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture92,
  mipLevel: 0,
  origin: {x: 66, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture23,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
},
{width: 53, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer75 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX, mappedAtCreation: false});
let commandEncoder85 = device0.createCommandEncoder({});
let texture109 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 24},
  dimension: '2d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder12.executeBundles([renderBundle2, renderBundle1, renderBundle11]);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer51, 'uint32', 8, 9);
} catch {}
try {
renderBundleEncoder16.drawIndexed(7, 0, 5, 137_722_904);
} catch {}
try {
commandEncoder74.insertDebugMarker('\u06fe');
} catch {}
document.body.prepend(img1);
let textureView95 = texture67.createView({});
try {
renderPassEncoder8.beginOcclusionQuery(1);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup8);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline7);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture61,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 22},
  aspect: 'all',
}, new Uint8Array(91).fill(114), /* required buffer size: 91 */
{offset: 91}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder86 = device0.createCommandEncoder({});
let textureView96 = texture11.createView({dimension: 'cube', format: 'rg32sint', mipLevelCount: 1, baseArrayLayer: 4});
let computePassEncoder21 = commandEncoder34.beginComputePass();
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: false, stencilReadOnly: true});
try {
computePassEncoder21.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup14, new Uint32Array(742), 382, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer14, 'uint16', 0, 0);
} catch {}
try {
renderBundleEncoder16.drawIndexed(5, 0, 10, 65_160_896);
} catch {}
try {
renderBundleEncoder16.drawIndexedIndirect(buffer62, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 11, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(2).fill(69), /* required buffer size: 2 */
{offset: 2}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'bt709'} });
try {
computePassEncoder20.setBindGroup(2, bindGroup24);
} catch {}
try {
renderBundleEncoder16.draw(48, 0, 1_282_109_639);
} catch {}
try {
renderBundleEncoder16.drawIndexed(3, 0, 19, 212_406_364);
} catch {}
try {
renderBundleEncoder16.drawIndexedIndirect(buffer52, 184);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
await gc();
let bindGroup41 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 2, resource: {buffer: buffer50, size: 24}},
    {binding: 1, resource: {buffer: buffer60, offset: 0, size: 552}},
    {binding: 168, resource: textureView85},
    {binding: 141, resource: sampler3},
    {binding: 0, resource: textureView26},
  ],
});
try {
renderBundleEncoder16.drawIndexed(21, 0, 4, -2_112_279_623);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer35);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await promise8;
} catch {}
let externalTexture10 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder12.setBindGroup(2, bindGroup17, new Uint32Array(569), 65, 0);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline3);
} catch {}
let textureView97 = texture83.createView({dimension: '2d-array'});
let texture110 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 32},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView98 = texture90.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
renderPassEncoder2.setIndexBuffer(buffer15, 'uint16', 0, 2);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup21, []);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer25, 'uint32', 8, 0);
} catch {}
try {
commandEncoder67.copyTextureToTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 639, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture66,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 63},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
let buffer76 = device0.createBuffer({size: 1008, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder87 = device0.createCommandEncoder({});
try {
renderPassEncoder21.setBindGroup(0, bindGroup7, new Uint32Array(173), 27, 0);
} catch {}
try {
renderBundleEncoder26.setBindGroup(2, bindGroup11, new Uint32Array(4029), 180, 0);
} catch {}
try {
renderBundleEncoder16.drawIndexed(10, 0, 13, 51_152_045);
} catch {}
try {
renderBundleEncoder16.drawIndexedIndirect(buffer62, 28);
} catch {}
await gc();
try {
renderBundleEncoder19.setPipeline(pipeline6);
} catch {}
await gc();
let imageData14 = new ImageData(44, 16);
let commandEncoder88 = device0.createCommandEncoder();
try {
renderPassEncoder15.setIndexBuffer(buffer43, 'uint16', 60, 0);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline6);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 21,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 76,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 286,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 332,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
  ],
});
try {
renderPassEncoder22.drawIndirect(buffer63, 0);
} catch {}
try {
renderBundleEncoder16.drawIndirect(buffer42, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer73, 'uint32', 20, 36);
} catch {}
let buffer77 = device0.createBuffer({
  size: 396,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder89 = device0.createCommandEncoder({});
let textureView99 = texture72.createView({dimension: '2d-array', arrayLayerCount: 1});
let renderBundle12 = renderBundleEncoder16.finish({});
try {
renderPassEncoder17.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder22.draw(69, 299, 2_592_803_054, 923_193_004);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer1, 52);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline7);
} catch {}
let buffer78 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder8.beginOcclusionQuery(239);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer48, 8);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup0);
} catch {}
try {
computePassEncoder2.insertDebugMarker('\u09ea');
} catch {}
let buffer79 = device0.createBuffer({size: 132, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
try {
renderPassEncoder23.setBindGroup(1, bindGroup17);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer52, 8);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer29, 4);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup7);
} catch {}
try {
buffer53.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas1);
let bindGroup42 = device0.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 20, resource: {buffer: buffer60}}]});
let externalTexture11 = device0.importExternalTexture({source: videoFrame6});
try {
renderPassEncoder22.drawIndirect(buffer4, 24);
} catch {}
try {
commandEncoder53.copyBufferToBuffer(buffer39, 8, buffer3, 4, 32);
} catch {}
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'gamma28curve'} });
let texture111 = device0.createTexture({
  size: [48, 48, 46],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let externalTexture12 = device0.importExternalTexture({source: videoFrame5});
try {
renderBundleEncoder5.setPipeline(pipeline18);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
let textureView100 = texture104.createView({mipLevelCount: 1});
try {
renderPassEncoder22.drawIndirect(buffer48, 0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline7);
} catch {}
await gc();
let buffer80 = device0.createBuffer({size: 36, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture112 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 37},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder25 = commandEncoder79.beginRenderPass({
  colorAttachments: [{
  view: textureView66,
  clearValue: { r: -368.2, g: 537.7, b: -492.1, a: -507.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder21.setBindGroup(1, bindGroup3, new Uint32Array(1300), 48, 0);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline18);
} catch {}
let pipeline19 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}});
let texture113 = device0.createTexture({
  size: [8, 8, 13],
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView101 = texture8.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 2});
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder22.draw(84, 34, 3_060_584_112, 422_780_312);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer4, 8);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer74, 'uint16', 10, 3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let bindGroup43 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 161, resource: externalTexture9}, {binding: 2, resource: textureView17}],
});
try {
renderPassEncoder22.draw(513, 401, 672_706_565, 608_961_857);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup3, new Uint32Array(1300), 366, 0);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer52, 16);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer29, 68, new DataView(new Uint8Array(756).map((_, i) => i).buffer), 8, 80);
} catch {}
let bindGroup44 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 2, resource: textureView29},
    {binding: 9, resource: externalTexture3},
    {binding: 20, resource: {buffer: buffer60}},
    {binding: 0, resource: textureView57},
  ],
});
let buffer81 = device0.createBuffer({size: 148, usage: GPUBufferUsage.STORAGE});
try {
computePassEncoder2.setBindGroup(1, bindGroup30, new Uint32Array(1902), 608, 0);
} catch {}
try {
renderPassEncoder22.draw(67, 34, 497_633_447, 424_565_443);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer1, 'uint32', 0, 3);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer77, 132, 5);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer50, 36);
} catch {}
try {
renderBundleEncoder1.drawIndirect(buffer63, 0);
} catch {}
try {
commandEncoder61.copyBufferToBuffer(buffer43, 72, buffer60, 136, 4);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let textureView102 = texture29.createView({});
try {
renderPassEncoder22.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder1.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer7, 4, 182);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 0, resource: textureView57},
    {binding: 9, resource: externalTexture3},
    {binding: 2, resource: textureView6},
    {binding: 20, resource: {buffer: buffer49}},
  ],
});
let texture114 = device0.createTexture({
  size: [12],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup2, []);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer62, 16);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer74, 'uint32', 0, 14);
} catch {}
let pipeline20 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, constants: {}}});
try {
gpuCanvasContext1.unconfigure();
} catch {}
let buffer82 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder90 = device0.createCommandEncoder({});
let texture115 = device0.createTexture({
  size: {width: 48},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder6.setBindGroup(0, bindGroup37, new Uint32Array(632), 57, 0);
} catch {}
try {
renderPassEncoder22.draw(14, 749, 197_940_735, 1_645_414_206);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer40, 84);
} catch {}
try {
renderBundleEncoder1.draw(108, 2, 669_579_461, 4);
} catch {}
try {
renderBundleEncoder1.drawIndirect(buffer4, 12);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer14, 'uint16', 4, 3);
} catch {}
try {
commandEncoder86.clearBuffer(buffer10);
} catch {}
let bindGroup46 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 4, resource: {buffer: buffer60}},
    {binding: 21, resource: externalTexture12},
    {binding: 76, resource: textureView2},
    {binding: 286, resource: {buffer: buffer7}},
    {binding: 332, resource: {buffer: buffer49}},
    {binding: 1, resource: textureView90},
    {binding: 16, resource: {buffer: buffer32, offset: 0, size: 48}},
  ],
});
let textureView103 = texture115.createView({});
let texture116 = device0.createTexture({
  size: [655, 1, 623],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder11.setBindGroup(1, bindGroup2, new Uint32Array(1843), 160, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder22.draw(227, 7, 252_468_945, 297_483_489);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer42, 4);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(7, buffer7);
} catch {}
try {
renderBundleEncoder1.draw(124, 5, 21_028_315, 5);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer52, 'uint32', 152, 4);
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u6334');
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'iec61966-2-1'} });
let buffer83 = device0.createBuffer({size: 196, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder91 = device0.createCommandEncoder({});
let texture117 = device0.createTexture({
  size: {width: 655},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture118 = device0.createTexture({
  size: {width: 24, height: 24, depthOrArrayLayers: 58},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder22.drawIndirect(buffer52, 96);
} catch {}
try {
  await promise11;
} catch {}
let buffer84 = device0.createBuffer({size: 208, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let textureView104 = texture117.createView({arrayLayerCount: 1});
let textureView105 = texture6.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
try {
renderPassEncoder22.draw(17, 151, 1_296_001_192, 1_444_720_309);
} catch {}
try {
renderBundleEncoder1.drawIndirect(buffer82, 0);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(48); };
} catch {}
let textureView106 = texture5.createView({});
try {
renderPassEncoder20.setPipeline(pipeline6);
} catch {}
try {
commandEncoder91.copyBufferToBuffer(buffer2, 0, buffer37, 20, 0);
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 10},
  aspect: 'all',
},
{
  texture: texture17,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder92 = device0.createCommandEncoder({});
let textureView107 = texture114.createView({aspect: 'all'});
let textureView108 = texture95.createView({baseArrayLayer: 0});
try {
renderPassEncoder20.drawIndexedIndirect(buffer63, 0);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer15, 0);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline7);
} catch {}
try {
commandEncoder62.resolveQuerySet(querySet1, 56, 61, buffer64, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let buffer85 = device0.createBuffer({size: 488, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder21.setStencilReference(448);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer83, 28);
} catch {}
try {
renderBundleEncoder1.draw(5, 10, 192_227_827, 1);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer61, 8);
} catch {}
let bindGroup47 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: {buffer: buffer79, size: 128}}, {binding: 0, resource: {buffer: buffer12}}],
});
let texture119 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder19.setIndexBuffer(buffer14, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup26, []);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer52, 72);
} catch {}
try {
commandEncoder59.copyTextureToBuffer({
  texture: texture98,
  mipLevel: 0,
  origin: {x: 102, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1608 widthInBlocks: 402 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1896 */
  offset: 1896,
  bytesPerRow: 3584,
  rowsPerImage: 843,
  buffer: buffer56,
}, {width: 402, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder88.insertDebugMarker('\u08ea');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
await gc();
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'film', transfer: 'iec61966-2-1'} });
let buffer86 = device0.createBuffer({size: 12, usage: GPUBufferUsage.VERTEX});
let texture120 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 33},
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture121 = device0.createTexture({
  label: '\u51e6\u00e6\u{1fddd}',
  size: [163, 1, 1],
  mipLevelCount: 5,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView109 = texture22.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder13.setBindGroup(1, bindGroup13, new Uint32Array(5553), 35, 0);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(48);
} catch {}
try {
renderPassEncoder20.drawIndexedIndirect(buffer52, 16);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture64,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(317).fill(220), /* required buffer size: 317 */
{offset: 317}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
document.body.append(img1);
let textureView110 = texture120.createView({dimension: '2d'});
let texture122 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder17.setBindGroup(0, bindGroup19, new Uint32Array(238), 6, 0);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer76, 204);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(2, buffer35, 0);
} catch {}
try {
commandEncoder48.copyBufferToBuffer(buffer75, 44, buffer60, 160, 8);
} catch {}
let bindGroup48 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 2, resource: textureView5}, {binding: 161, resource: externalTexture2}],
});
let commandEncoder93 = device0.createCommandEncoder({});
let textureView111 = texture65.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 4});
try {
renderPassEncoder20.draw(119, 40, 2_020_413_225, 53_699_632);
} catch {}
try {
renderBundleEncoder1.drawIndirect(buffer63, 0);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(0, buffer51, 24);
} catch {}
let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt709', transfer: 'smpte240m'} });
try {
computePassEncoder2.setBindGroup(2, bindGroup12);
} catch {}
try {
renderPassEncoder12.end();
} catch {}
try {
renderPassEncoder22.draw(257, 482, 507_695_113, 1_465_543_282);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer84, 16);
} catch {}
try {
renderBundleEncoder26.setBindGroup(2, bindGroup1, []);
} catch {}
try {
buffer79.unmap();
} catch {}
try {
commandEncoder51.clearBuffer(buffer47);
} catch {}
try {
commandEncoder66.resolveQuerySet(querySet1, 45, 0, buffer2, 0);
} catch {}
let commandEncoder94 = device0.createCommandEncoder();
try {
renderPassEncoder20.end();
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle10]);
} catch {}
try {
renderPassEncoder22.draw(144, 95, 306_197_289, 485_225_394);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup43, new Uint32Array(80), 8, 0);
} catch {}
let commandEncoder95 = device0.createCommandEncoder({});
let textureView112 = texture97.createView({dimension: '3d'});
try {
computePassEncoder8.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer78, 'uint16', 4, 9);
} catch {}
try {
renderBundleEncoder26.setBindGroup(0, bindGroup15);
} catch {}
let commandEncoder96 = device0.createCommandEncoder();
try {
renderPassEncoder25.setIndexBuffer(buffer47, 'uint32', 8, 4);
} catch {}
try {
buffer76.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 1,
  origin: {x: 13, y: 5, z: 19},
  aspect: 'all',
}, new Uint8Array(6_145).fill(241), /* required buffer size: 6_145 */
{offset: 3, bytesPerRow: 14, rowsPerImage: 109}, {width: 5, height: 3, depthOrArrayLayers: 5});
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 79,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
  ],
});
let textureView113 = texture57.createView({mipLevelCount: 1, arrayLayerCount: 1});
let externalTexture13 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder3.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer48, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer4, 4);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder96.insertDebugMarker('\u{1fe89}');
} catch {}
let recycledExplicitBindGroupLayout0 = pipeline8.getBindGroupLayout(3);
let buffer87 = device0.createBuffer({size: 248, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder97 = device0.createCommandEncoder({});
let texture123 = device0.createTexture({
  size: {width: 24, height: 24, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder1.setBindGroup(3, bindGroup16);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup0, new Uint32Array(464), 37, 0);
} catch {}
try {
renderBundleEncoder1.draw(34, 5, 261_599_340);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer1, 64);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await promise12;
} catch {}
let sampler16 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMaxClamp: 92.23,
  maxAnisotropy: 1,
});
try {
computePassEncoder19.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder22.draw(175, 91, 723_122_801, 850_336_577);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer14, 'uint32', 4, 4);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup26, new Uint32Array(357), 192, 0);
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
try {
  await promise13;
} catch {}
try {
computePassEncoder13.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder11.setBindGroup(1, bindGroup48, new Uint32Array(380), 7, 0);
} catch {}
try {
renderBundleEncoder1.drawIndexedIndirect(buffer61, 0);
} catch {}
try {
commandEncoder50.copyBufferToBuffer(buffer43, 0, buffer29, 80, 12);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup8, new Uint32Array(2130), 1_004, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 11,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 19,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 29,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 161,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 433,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
  ],
});
try {
renderPassEncoder3.setBindGroup(2, bindGroup32);
} catch {}
try {
renderPassEncoder22.draw(304, 313, 2_447_513_192, 524_680_204);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer52, 8);
} catch {}
try {
renderBundleEncoder23.setBindGroup(0, bindGroup34);
} catch {}
try {
computePassEncoder18.setBindGroup(3, bindGroup31);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup38);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup5, new Uint32Array(3594), 220, 0);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder22.draw(296, 108, 1_064_929_283, 930_660_216);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer83, 44);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup5);
} catch {}
try {
renderBundleEncoder1.draw(17, 2, 188_164_938, 1);
} catch {}
try {
renderBundleEncoder1.drawIndirect(buffer42, 0);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline17);
} catch {}
let textureView114 = texture110.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5});
let renderBundle13 = renderBundleEncoder1.finish();
try {
renderPassEncoder19.setBindGroup(0, bindGroup16, []);
} catch {}
try {
renderPassEncoder22.draw(114, 44, 3_086_715_070, 107_714_945);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer61, 16);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(1, buffer86);
} catch {}
let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder21.setBindGroup(2, bindGroup46, new Uint32Array(7), 0, 2);
} catch {}
try {
renderPassEncoder22.draw(6, 138, 1_315_408_354, 1_405_024_447);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer14, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline16);
} catch {}
try {
commandEncoder39.insertDebugMarker('\uaa3c');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline21 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule2, constants: {}, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}]},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 12,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 12},
          {format: 'snorm16x4', offset: 0, shaderLocation: 1},
          {format: 'uint16x2', offset: 0, shaderLocation: 11},
          {format: 'sint32x2', offset: 0, shaderLocation: 9},
          {format: 'uint8x2', offset: 2, shaderLocation: 2},
          {format: 'float32', offset: 0, shaderLocation: 15},
          {format: 'float32', offset: 0, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
document.body.append(canvas0);
let texture124 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 327},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder5.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup44);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup37, new Uint32Array(1842), 9, 0);
} catch {}
try {
renderPassEncoder22.draw(146, 1, 613_493_963, 19_320_551);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer63, 4);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer43, 'uint32', 4, 6);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline17);
} catch {}
try {
commandEncoder55.insertDebugMarker('\u09b6');
} catch {}
try {
device0.queue.writeBuffer(buffer60, 148, new Float32Array(2340).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.08862)), 465, 4);
} catch {}
let texture125 = device0.createTexture({
  label: '\u0c61\u{1f6f2}\u0f2a\u7879\u6cd5\u{1fc3e}\u98ea\u0a40\uad89\u308e\u8245',
  size: {width: 327},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup2);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
let texture126 = device0.createTexture({
  size: [48, 48, 150],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder10.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup19, []);
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline12);
} catch {}
try {
  await promise15;
} catch {}
let buffer88 = device0.createBuffer({size: 272, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let textureView115 = texture40.createView({});
try {
computePassEncoder6.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder22.draw(70, 79, 63_703_371, 496_387_400);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(0, buffer41, 0);
} catch {}
try {
commandEncoder86.copyTextureToTexture({
  texture: texture82,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder67.insertDebugMarker('\u19bd');
} catch {}
try {
renderPassEncoder10.insertDebugMarker('\u00bc');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires unrestricted_pointer_parameters;

requires readonly_and_readwrite_storage_textures;

fn unconst_f16(v: f16) -> f16 { return v; }

fn unconst_u32(v: u32) -> u32 { return v; }

@group(0) @binding(1) var<storage, read_write> buffer90: array<array<vec4u, 8>>;

fn unconst_bool(v: bool) -> bool { return v; }

fn unconst_i32(v: i32) -> i32 { return v; }

struct ComputeInput7 {
  @builtin(local_invocation_id) local_invocation_id: vec3u,
  @builtin(local_invocation_index) local_invocation_index: u32,
}

override override10: f16;

struct FragmentInput14 {
  @builtin(front_facing) front_facing: bool,
  @builtin(position) position: vec4f,
  @builtin(sample_mask) sample_mask: u32,
}

override override13 = 0.2414e22;

alias vec3b = vec3<bool>;

@id(60922) override override12: u32;

struct FragmentOutput7 {
  @location(0) @interpolate(flat, centroid) location_0: vec2u,
}

fn unconst_f32(v: f32) -> f32 { return v; }

struct T0 {
  f0: array<u32>,
}

struct ComputeInput9 {
  @builtin(num_workgroups) num_workgroups: vec3u,
}

override override11 = 0.07308;

@group(0) @binding(0) var<storage, read_write> buffer89: array<array<array<f16, 1>, 29>>;

struct ComputeInput8 {
  @builtin(workgroup_id) workgroup_id: vec3u,
}

/* used global variables: buffer89, buffer90 */
@fragment
fn fragment7(a0: FragmentInput14, @builtin(sample_index) sample_index: u32) -> FragmentOutput7 {
  var out: FragmentOutput7;
  let ptr26: ptr<storage, array<array<f16, 1>, 29>, read_write> = &(*&buffer89)[arrayLength(&(*&buffer89))];
  buffer90[unconst_u32(1559401960)][unconst_u32(63495344)] += vec4u(u32((*ptr26)[unconst_u32(1019319532)][0]));
  let ptr27: ptr<storage, vec4u, read_write> = &(*&buffer90)[arrayLength(&(*&buffer90))][7];
  let ptr28: ptr<storage, array<array<f16, 1>, 29>, read_write> = &(*&buffer89)[unconst_u32(3849732097)];
  let ptr29: ptr<storage, array<f16, 1>, read_write> = &buffer89[arrayLength(&buffer89)][unconst_u32(589559196)];
  buffer89[u32((*&buffer89)[arrayLength(&(*&buffer89))][unconst_u32(1060439717)][0])][unconst_u32(326766493)][unconst_u32(154094819)] = vec4h((*&buffer90)[unconst_i32(13663218)][7])[3];
  let ptr30: ptr<storage, vec4u, read_write> = &(*&buffer90)[unconst_u32(189457474)][7];
  switch i32((*&buffer89)[unconst_u32(54679169)][28][0]) { 
  case default {
  buffer89[unconst_u32(670204027)][bitcast<u32>(override13)][unconst_u32(153793482)] = f16(arrayLength(&buffer89));
  _ = override13;
  _ = buffer89;
}
  }
  let ptr31: ptr<storage, array<array<f16, 1>, 29>, read_write> = &buffer89[unconst_u32(151772330)];
  buffer90[unconst_u32(733684571)][unconst_u32(406445531)] += bitcast<vec4u>((unconst_i32(-213896451) - vec4i(unconst_i32(-25451390), unconst_i32(713135815), unconst_i32(967226692), unconst_i32(-1941082271))).rrbr.ragg.wwwz.wwxz);
  let ptr32: ptr<storage, f16, read_write> = &(*ptr28)[unconst_u32(1374001242)][unconst_u32(61310411)];
  return out;
  _ = override13;
  _ = buffer89;
  _ = buffer90;
}

/* used global variables: buffer89 */
@compute @workgroup_size(1, 2, 1)
fn compute6(a0: ComputeInput7, a1: ComputeInput8, a2: ComputeInput9) {
  buffer89[unconst_u32(1252158667)][unconst_u32(23924862)][unconst_u32(3066123064)] += vec3h(a2.num_workgroups.rbg)[1];
  _ = buffer89;
}`,
});
let textureView116 = texture67.createView({dimension: '2d-array'});
try {
renderPassEncoder22.end();
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer83, 'uint16', 28, 54);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(7, buffer40, 0, 0);
} catch {}
let imageData15 = new ImageData(12, 8);
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout4]});
let texture127 = device0.createTexture({
  size: [163, 1, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
commandEncoder64.insertDebugMarker('\u0b28');
} catch {}
offscreenCanvas1.width = 645;
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 72,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder98 = device0.createCommandEncoder();
let texture128 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder19.setIndexBuffer(buffer47, 'uint32', 0, 4);
} catch {}
try {
  await promise14;
} catch {}
await gc();
let canvas2 = document.createElement('canvas');
let buffer91 = device0.createBuffer({size: 744, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let texture129 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder17.setBindGroup(1, bindGroup17);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup18, new Uint32Array(1505), 118, 0);
} catch {}
try {
renderBundleEncoder24.setBindGroup(3, bindGroup28, new Uint32Array(1638), 350, 0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
await gc();
let texture130 = device0.createTexture({
  size: [327, 1, 55],
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rg8uint'],
});
let textureView117 = texture26.createView({baseArrayLayer: 9, arrayLayerCount: 2});
let renderPassEncoder26 = commandEncoder59.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: 755.7, g: -157.3, b: 730.3, a: -951.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 225887245,
});
try {
renderPassEncoder6.setIndexBuffer(buffer91, 'uint32', 16, 32);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder21.insertDebugMarker('\u{1f84a}');
} catch {}
try {
device0.queue.writeBuffer(buffer0, 16, new BigInt64Array(7643).map((_, i) => BigInt(i - 5)), 196, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer92 = device0.createBuffer({size: 24, usage: GPUBufferUsage.INDEX, mappedAtCreation: false});
let sampler17 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 86.86,
  maxAnisotropy: 18,
});
try {
renderPassEncoder26.setBindGroup(0, bindGroup27);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(1, buffer84, 0);
} catch {}
try {
buffer42.unmap();
} catch {}
let buffer93 = device0.createBuffer({
  size: 18,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
});
let commandEncoder99 = device0.createCommandEncoder({});
let textureView118 = texture92.createView({dimension: '2d-array', baseArrayLayer: 3, arrayLayerCount: 1});
try {
renderBundleEncoder24.setIndexBuffer(buffer51, 'uint16', 0, 8);
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\ub2d1');
} catch {}
let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
try {
computePassEncoder8.setBindGroup(3, bindGroup26, new Uint32Array(415), 96, 0);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline1);
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
let commandEncoder100 = device0.createCommandEncoder({});
let texture131 = device0.createTexture({
  size: [12],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder3.setVertexBuffer(2, buffer2);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer52, 'uint32', 132, 17);
} catch {}
let buffer94 = device0.createBuffer({
  size: 212,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder101 = device0.createCommandEncoder();
let texture132 = device0.createTexture({
  size: [12, 12, 37],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder21.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer55, 0, 45);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 44, new Float64Array(1591).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/1587)), 73, 4);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext3 = canvas2.getContext('webgpu');
try {
  await promise17;
} catch {}
let bindGroup49 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 194, resource: externalTexture8},
    {binding: 0, resource: {buffer: buffer85, offset: 0, size: 312}},
    {binding: 108, resource: sampler0},
    {binding: 16, resource: externalTexture5},
    {binding: 2, resource: textureView105},
  ],
});
let commandEncoder102 = device0.createCommandEncoder({});
try {
computePassEncoder9.setBindGroup(3, bindGroup48);
} catch {}
try {
computePassEncoder20.setBindGroup(1, bindGroup2, new Uint32Array(185), 84, 0);
} catch {}
try {
renderPassEncoder16.setBlendConstant({ r: 696.7, g: 255.1, b: -381.8, a: 646.5, });
} catch {}
try {
  await promise16;
} catch {}
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte432', transfer: 'bt709'} });
let bindGroup50 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout9,
  entries: [{binding: 1, resource: {buffer: buffer37, size: 148}}],
});
let textureView119 = texture98.createView({arrayLayerCount: 1});
try {
renderPassEncoder2.setBindGroup(1, bindGroup1, new Uint32Array(4966), 138, 0);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer4, 0);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer52, 'uint32', 108, 6);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(0, buffer87, 0, 38);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let bindGroup51 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [{binding: 0, resource: {buffer: buffer30}}, {binding: 1, resource: {buffer: buffer38}}],
});
let pipelineLayout4 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout1, recycledExplicitBindGroupLayout0, veryExplicitBindGroupLayout6],
});
let texture133 = device0.createTexture({
  size: [24],
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder11.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup45, new Uint32Array(416), 12, 0);
} catch {}
try {
renderBundleEncoder31.setIndexBuffer(buffer39, 'uint16', 204, 15);
} catch {}
try {
buffer24.unmap();
} catch {}
let imageData16 = new ImageData(24, 16);
let texture134 = device0.createTexture({
  size: {width: 12},
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView120 = texture15.createView({dimension: '2d-array'});
try {
renderPassEncoder2.drawIndirect(buffer61, 12);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer43, 'uint16', 8, 25);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup30, new Uint32Array(931), 269, 0);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(5, buffer57, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer56, 1_284, new Uint16Array(2271).map((_, i) => i + 10), 290, 256);
} catch {}
let texture135 = device0.createTexture({
  size: [6],
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
let sampler18 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 91.91});
try {
computePassEncoder11.setBindGroup(0, bindGroup6, new Uint32Array(513), 39, 0);
} catch {}
try {
renderPassEncoder11.end();
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle8]);
} catch {}
try {
renderPassEncoder2.draw(248, 5, 232_915_986);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer40, 76);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer74, 'uint16', 4, 13);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 119, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(472).fill(193), /* required buffer size: 472 */
{offset: 472}, {width: 138, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture136 = device0.createTexture({
  size: [48],
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture137 = gpuCanvasContext0.getCurrentTexture();
let sampler19 = device0.createSampler({addressModeW: 'repeat', compare: 'always'});
try {
renderPassEncoder24.setIndexBuffer(buffer25, 'uint32', 4, 1);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline8);
} catch {}
try {
commandEncoder95.copyTextureToBuffer({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 59, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1386 */
  offset: 1386,
  bytesPerRow: 19200,
  buffer: buffer56,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder14.pushDebugGroup('\u0648');
} catch {}
try {
renderBundleEncoder14.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture103,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(595).fill(167), /* required buffer size: 595 */
{offset: 595, bytesPerRow: 18}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img2);
try {
externalTexture7.label = '\u{1fd15}\u{1f9a4}';
} catch {}
let texture138 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 1},
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder18.setBindGroup(3, bindGroup43);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer7, 32, 65);
} catch {}
try {
renderBundleEncoder28.setBindGroup(2, bindGroup13);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer47, 'uint16', 4, 2);
} catch {}
let canvas3 = document.createElement('canvas');
let bindGroup52 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer77}}]});
let commandEncoder103 = device0.createCommandEncoder({});
let textureView121 = texture135.createView({});
let texture139 = device0.createTexture({size: [48, 48, 47], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
let externalTexture14 = device0.importExternalTexture({source: videoFrame5});
try {
renderPassEncoder2.drawIndirect(buffer61, 20);
} catch {}
let gpuCanvasContext4 = canvas3.getContext('webgpu');
let commandEncoder104 = device0.createCommandEncoder();
let textureView122 = texture138.createView({mipLevelCount: 1});
let textureView123 = texture34.createView({});
try {
renderPassEncoder1.setBindGroup(1, bindGroup45, []);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer93, 0);
} catch {}
try {
commandEncoder94.copyBufferToBuffer(buffer93, 0, buffer85, 348, 0);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 1,
  origin: {x: 26, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(2_176).fill(218), /* required buffer size: 2_176 */
{offset: 10, bytesPerRow: 19, rowsPerImage: 38}, {width: 7, height: 0, depthOrArrayLayers: 4});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder11.setBindGroup(3, bindGroup22, new Uint32Array(1472), 36, 0);
} catch {}
try {
renderPassEncoder2.drawIndexed(1, 16, 0, -1_937_787_561, 10);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer94, 0);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer94, 20);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer77, 0, 161);
} catch {}
try {
renderBundleEncoder28.setBindGroup(3, bindGroup10);
} catch {}
try {
buffer31.unmap();
} catch {}
let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder2.drawIndexed(1, 48, 0, 774_632_032, 24);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder17.setBindGroup(1, bindGroup51);
} catch {}
try {
renderBundleEncoder23.insertDebugMarker('\u{1fa71}');
} catch {}
let buffer95 = device0.createBuffer({
  size: 68,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
  mappedAtCreation: false,
});
let commandEncoder105 = device0.createCommandEncoder({});
try {
renderPassEncoder2.drawIndexed(1, 63, 0, 215_938_365, 41);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer43, 'uint32', 0, 29);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup10, new Uint32Array(443), 163, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 0, new Uint32Array(36222).map((_, i) => i * 9), 1964, 0);
} catch {}
try {
globalThis.someLabel = externalTexture12.label;
} catch {}
let commandEncoder106 = device0.createCommandEncoder();
let commandBuffer4 = commandEncoder41.finish({});
try {
computePassEncoder9.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup6, []);
} catch {}
try {
renderPassEncoder2.draw(445, 34, 686_996_093, 29);
} catch {}
try {
renderPassEncoder2.drawIndexed(1, 74, 0, 525_857_946, 16);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer62, 12);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer39, 'uint16', 88, 129);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(1, buffer51, 0);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(2, buffer47);
} catch {}
let pipeline22 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
try {
  await promise10;
} catch {}
let bindGroup53 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 35, resource: sampler9},
    {binding: 123, resource: textureView8},
    {binding: 493, resource: textureView52},
    {binding: 353, resource: textureView10},
    {binding: 241, resource: textureView76},
    {binding: 274, resource: externalTexture4},
  ],
});
let texture140 = device0.createTexture({
  size: [6, 6, 18],
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder17.setBindGroup(2, bindGroup47);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline11);
} catch {}
try {
commandEncoder106.clearBuffer(buffer47);
} catch {}
let autogeneratedBindGroupLayout10 = pipeline18.getBindGroupLayout(0);
let texture141 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 37},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder2.drawIndexedIndirect(buffer95, 0);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(1, buffer29, 48, 45);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 21,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 76,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 286,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 332,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
  ],
});
let buffer96 = device0.createBuffer({
  size: 252,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
try {
renderPassEncoder8.beginOcclusionQuery(80);
} catch {}
try {
renderPassEncoder3.setStencilReference(158);
} catch {}
try {
renderPassEncoder2.draw(35, 2, 135_381_504, 30);
} catch {}
try {
renderPassEncoder2.drawIndexed(1, 50, 0, -2_053_528_544, 41);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer40, 20);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(0, buffer77);
} catch {}
document.body.prepend(img0);
let textureView124 = texture119.createView({});
let texture142 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 37},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView125 = texture1.createView({dimension: '2d', baseArrayLayer: 2, arrayLayerCount: 1});
let sampler20 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'linear', minFilter: 'linear'});
try {
renderPassEncoder16.setIndexBuffer(buffer95, 'uint32', 20, 1);
} catch {}
try {
renderBundleEncoder24.draw(65, 1, 290_840_847);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline6);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup54 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer30}}]});
let buffer97 = device0.createBuffer({size: 228, usage: GPUBufferUsage.COPY_SRC});
let texture143 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture144 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 94},
  mipLevelCount: 3,
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder2.end();
} catch {}
try {
renderBundleEncoder27.drawIndirect(buffer50, 16);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(3, buffer84, 36, 10);
} catch {}
let buffer98 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_DST});
let textureView126 = texture105.createView({format: 'r32float'});
let renderBundle14 = renderBundleEncoder27.finish({});
try {
renderPassEncoder16.setVertexBuffer(0, buffer88, 0, 7);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup15, new Uint32Array(555), 56, 0);
} catch {}
try {
renderBundleEncoder24.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(7, buffer41, 0, 0);
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 0, resource: textureView57},
    {binding: 9, resource: externalTexture6},
    {binding: 20, resource: {buffer: buffer60}},
    {binding: 2, resource: textureView6},
  ],
});
let texture145 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  dimension: '2d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder27 = commandEncoder61.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: 145.4, g: -805.1, b: 318.4, a: 524.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let renderBundleEncoder34 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], stencilReadOnly: true});
try {
renderPassEncoder3.setBindGroup(2, bindGroup9, new Uint32Array(237), 46, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder31.setPipeline(pipeline14);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let bindGroup56 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 2, resource: textureView84},
    {binding: 9, resource: externalTexture3},
    {binding: 20, resource: {buffer: buffer77}},
    {binding: 0, resource: textureView57},
  ],
});
let commandEncoder107 = device0.createCommandEncoder({});
let textureView127 = texture145.createView({baseArrayLayer: 5, arrayLayerCount: 3});
let renderBundle15 = renderBundleEncoder24.finish({});
try {
renderPassEncoder6.setIndexBuffer(buffer1, 'uint16', 102, 20);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer25, 'uint32', 0, 13);
} catch {}
try {
commandEncoder97.copyBufferToBuffer(buffer52, 16, buffer39, 0, 156);
} catch {}
try {
device0.queue.writeBuffer(buffer78, 0, new Float32Array(24081).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.09030)), 1590, 0);
} catch {}
let pipeline23 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4', constants: {}}});
let bindGroup57 = device0.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 20, resource: {buffer: buffer77}}]});
let computePassEncoder22 = commandEncoder42.beginComputePass();
try {
computePassEncoder22.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup48, new Uint32Array(1029), 53, 0);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer84, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer91, 'uint16', 186, 286);
} catch {}
try {
renderBundleEncoder33.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder12.insertDebugMarker('\ua1cb');
} catch {}
let texture146 = device0.createTexture({
  size: [8, 8, 13],
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView128 = texture93.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder1.setBindGroup(1, bindGroup25);
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle0]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture127,
  mipLevel: 0,
  origin: {x: 143, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(5).fill(156), /* required buffer size: 5 */
{offset: 5}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder108 = device0.createCommandEncoder({});
try {
renderPassEncoder13.end();
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer14, 'uint16', 0, 5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(317).fill(240), /* required buffer size: 317 */
{offset: 317, rowsPerImage: 73}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout11 = pipeline23.getBindGroupLayout(0);
let texture147 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 13},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView129 = texture100.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder11.setBindGroup(2, bindGroup41, new Uint32Array(2048), 860, 1);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer92, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer15, 'uint32', 0, 1);
} catch {}
try {
renderPassEncoder24.insertDebugMarker('\u{1fe98}');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(149).fill(246), /* required buffer size: 149 */
{offset: 149}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer99 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder109 = device0.createCommandEncoder();
try {
renderPassEncoder17.setBindGroup(2, bindGroup37);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let buffer100 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDEX, mappedAtCreation: false});
let texture148 = device0.createTexture({
  size: [8],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView130 = texture59.createView({baseArrayLayer: 0});
try {
computePassEncoder19.setBindGroup(1, bindGroup35, new Uint32Array(604), 89, 0);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(122);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer52, 'uint16', 18, 35);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
renderPassEncoder24.setBindGroup(2, bindGroup2, new Uint32Array(2210), 493, 0);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder25.insertDebugMarker('\u0be9');
} catch {}
try {
device0.queue.writeBuffer(buffer3, 12, new Uint32Array(1563).map((_, i) => i * 9), 243, 4);
} catch {}
let commandEncoder110 = device0.createCommandEncoder({});
let texture149 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture150 = gpuCanvasContext1.getCurrentTexture();
let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
renderPassEncoder23.setBindGroup(0, bindGroup19, new Uint32Array(1058), 214, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer25, 'uint16', 8, 2);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer75, 8);
} catch {}
try {
commandEncoder74.resolveQuerySet(querySet0, 53, 2, buffer12, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer45, 112, new Float32Array(3563).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.879)), 71, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let textureView131 = texture29.createView({});
try {
renderPassEncoder21.draw(79, 0, 402_886_764);
} catch {}
try {
renderPassEncoder21.drawIndexed(2, 0, 0, 37_340_947, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(2, buffer2, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(192).fill(92), /* required buffer size: 192 */
{offset: 192, bytesPerRow: 49}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup58 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout6,
  entries: [{binding: 20, resource: {buffer: buffer49, offset: 0, size: 396}}],
});
let texture151 = gpuCanvasContext2.getCurrentTexture();
let textureView132 = texture65.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6});
try {
computePassEncoder0.setBindGroup(0, bindGroup35, new Uint32Array(2296), 511, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup15, new Uint32Array(2768), 658, 0);
} catch {}
try {
renderPassEncoder21.draw(26, 0, 1_837_933_853);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer52, 4);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer4, 12);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup10);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline6);
} catch {}
document.body.prepend(img0);
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }},
    {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 97, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 131,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 191,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {binding: 223, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 254,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let texture152 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView133 = texture134.createView({});
try {
renderPassEncoder24.setBindGroup(2, bindGroup13);
} catch {}
try {
renderPassEncoder21.draw(253, 0, 445_261_555, 0);
} catch {}
try {
renderPassEncoder21.drawIndexed(2, 0, 0, 152_145_565);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer85, 'uint32', 44, 3);
} catch {}
try {
commandEncoder73.insertDebugMarker('\u9300');
} catch {}
try {
computePassEncoder4.insertDebugMarker('\u2309');
} catch {}
let canvas4 = document.createElement('canvas');
let textureView134 = texture143.createView({dimension: '2d-array', aspect: 'all', format: 'r32uint', baseMipLevel: 0, baseArrayLayer: 0});
try {
renderPassEncoder6.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder25.beginOcclusionQuery(80);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder21.draw(164, 0, 376_157_034);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer62, 8);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, buffer47, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer91, 'uint16', 0, 101);
} catch {}
try {
buffer58.unmap();
} catch {}
try {
commandEncoder110.resolveQuerySet(querySet1, 9, 1, buffer51, 0);
} catch {}
try {
commandEncoder64.insertDebugMarker('\u{1f6ee}');
} catch {}
let pipeline24 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4', constants: {}}});
let buffer101 = device0.createBuffer({size: 110, usage: GPUBufferUsage.INDIRECT});
let commandEncoder111 = device0.createCommandEncoder({});
let commandBuffer5 = commandEncoder27.finish();
try {
renderPassEncoder24.setBindGroup(0, bindGroup1, new Uint32Array(3238), 85, 0);
} catch {}
try {
renderPassEncoder21.draw(311, 0, 187_415_299, 0);
} catch {}
try {
renderPassEncoder21.drawIndexed(2, 0, 0, 105_090_219);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer50, 8);
} catch {}
try {
renderBundleEncoder32.setBindGroup(2, bindGroup54, new Uint32Array(523), 18, 0);
} catch {}
try {
renderBundleEncoder35.drawIndexedIndirect(buffer42, 16);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 142 widthInBlocks: 71 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 332 */
  offset: 332,
  buffer: buffer60,
}, {
  texture: texture43,
  mipLevel: 1,
  origin: {x: 59, y: 0, z: 0},
  aspect: 'all',
}, {width: 71, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let texture153 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 21},
  mipLevelCount: 2,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundle16 = renderBundleEncoder35.finish({});
try {
computePassEncoder11.setBindGroup(3, bindGroup13, new Uint32Array(1337), 198, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder21.draw(59, 0, 145_790_958);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer1, 132);
} catch {}
try {
renderBundleEncoder33.setBindGroup(0, bindGroup21);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline21);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let buffer102 = device0.createBuffer({size: 192, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: false});
try {
renderPassEncoder16.executeBundles([renderBundle2, renderBundle2, renderBundle2, renderBundle16]);
} catch {}
try {
renderPassEncoder21.drawIndexed(2, 0, 0, 909_204_926);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer74, 'uint32', 4, 7);
} catch {}
try {
renderBundleEncoder31.setIndexBuffer(buffer51, 'uint32', 8, 0);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(0, buffer57);
} catch {}
try {
device0.queue.writeBuffer(buffer98, 0, new DataView(new Uint8Array(3729).map((_, i) => i).buffer), 537, 0);
} catch {}
let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let bindGroup59 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [
    {binding: 0, resource: textureView10},
    {binding: 9, resource: externalTexture10},
    {binding: 20, resource: {buffer: buffer49}},
  ],
});
let commandEncoder113 = device0.createCommandEncoder();
let commandBuffer6 = commandEncoder18.finish({});
try {
renderPassEncoder21.draw(7, 0, 30_218_861);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer39, 'uint16', 8, 390);
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(76); };
} catch {}
let buffer103 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false});
let commandEncoder114 = device0.createCommandEncoder({});
let commandBuffer7 = commandEncoder9.finish();
let textureView135 = texture59.createView({});
try {
renderPassEncoder21.drawIndexed(2, 0, 0, 52_380_273, 0);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer93, 0);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup47, new Uint32Array(1417), 652, 0);
} catch {}
let videoFrame23 = videoFrame13.clone();
let bindGroup60 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 2, resource: {buffer: buffer85}},
    {binding: 0, resource: textureView44},
    {binding: 168, resource: textureView28},
    {binding: 141, resource: sampler14},
    {binding: 1, resource: {buffer: buffer60}},
  ],
});
let commandBuffer8 = commandEncoder73.finish({label: '\ua303\u{1faa3}\u4604\u0d10\u0bad\u{1fee9}'});
let texture154 = device0.createTexture({
  size: {width: 655, height: 1, depthOrArrayLayers: 28},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView136 = texture15.createView({dimension: '2d', arrayLayerCount: 1});
try {
renderPassEncoder6.setIndexBuffer(buffer100, 'uint32', 80, 3);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer39, 88, new Float64Array(7379).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/7377)), 450, 0);
} catch {}
let commandBuffer9 = commandEncoder22.finish();
try {
renderPassEncoder3.setBindGroup(2, bindGroup32);
} catch {}
try {
renderPassEncoder21.end();
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer39, 'uint32', 44, 17);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer96, 'uint16', 34, 7);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer98, 4, new Float32Array(7806).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4281)), 537, 4);
} catch {}
let buffer104 = device0.createBuffer({size: 28, usage: GPUBufferUsage.STORAGE});
let textureView137 = texture97.createView({format: 'rgba32float', mipLevelCount: 1});
let textureView138 = texture55.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder18.setBindGroup(1, bindGroup15, new Uint32Array(616), 72, 0);
} catch {}
try {
renderPassEncoder25.setBindGroup(2, bindGroup58);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer25, 'uint32', 8, 1);
} catch {}
try {
device0.queue.submit([commandBuffer9, commandBuffer6, commandBuffer5]);
} catch {}
try {
device0.queue.writeBuffer(buffer87, 100, new Uint32Array(33832).map((_, i) => i * 2), 3853, 4);
} catch {}
let commandBuffer10 = commandEncoder40.finish();
try {
renderPassEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(2294), 691, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer39, 'uint16', 68, 3);
} catch {}
try {
renderBundleEncoder36.setBindGroup(3, bindGroup3);
} catch {}
try {
renderBundleEncoder33.setPipeline(pipeline15);
} catch {}
try {
buffer30.destroy();
} catch {}
let buffer105 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture155 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 41},
  mipLevelCount: 2,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder36.setIndexBuffer(buffer91, 'uint16', 8, 58);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let buffer106 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let texture156 = device0.createTexture({
  size: [6],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView139 = texture55.createView({aspect: 'all'});
let sampler21 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMinClamp: 91.19, lodMaxClamp: 96.01});
try {
renderPassEncoder25.endOcclusionQuery();
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer74, 'uint16', 2, 0);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup24, new Uint32Array(168), 28, 0);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(3, buffer102);
} catch {}
try {
commandEncoder81.clearBuffer(buffer29);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 28, new Float16Array(694).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.7787)), 230, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline25 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {module: shaderModule3, entryPoint: 'vertex2', constants: {}, buffers: []},
  primitive: {frontFace: 'cw', cullMode: 'front', unclippedDepth: false},
});
document.body.append(canvas4);
let bindGroup61 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 194, resource: externalTexture1},
    {binding: 108, resource: sampler7},
    {binding: 0, resource: {buffer: buffer72}},
    {binding: 2, resource: textureView19},
    {binding: 16, resource: externalTexture5},
  ],
});
let texture157 = device0.createTexture({
  size: [163],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder8.beginOcclusionQuery(246);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(0, buffer29);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer100, 'uint16', 34, 15);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(7, buffer106, 0, 1);
} catch {}
try {
device0.queue.submit([commandBuffer8, commandBuffer1]);
} catch {}
document.body.append(canvas1);
try {
adapter0.label = '\u0f57\u7455\ua83e\u6597\u8144\u5c2b\u82c5';
} catch {}
let buffer107 = device0.createBuffer({size: 56, usage: GPUBufferUsage.COPY_DST});
let texture158 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 13},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder16.setIndexBuffer(buffer47, 'uint32', 0, 3);
} catch {}
try {
commandEncoder38.copyBufferToBuffer(buffer2, 4, buffer103, 4, 0);
} catch {}
let pipeline26 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  fragment: {module: shaderModule6, constants: {}, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL}]},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 120,
        attributes: [
          {format: 'float32', offset: 4, shaderLocation: 15},
          {format: 'sint8x4', offset: 0, shaderLocation: 9},
          {format: 'uint32x3', offset: 12, shaderLocation: 11},
          {format: 'uint32x2', offset: 0, shaderLocation: 2},
          {format: 'float32x3', offset: 36, shaderLocation: 12},
          {format: 'float16x2', offset: 0, shaderLocation: 1},
          {format: 'float32x3', offset: 28, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
let gpuCanvasContext5 = canvas4.getContext('webgpu');
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(58); };
} catch {}
try {
computePassEncoder15.setBindGroup(1, bindGroup45);
} catch {}
try {
computePassEncoder8.setBindGroup(1, bindGroup23, new Uint32Array(153), 37, 0);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup16);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(1, buffer94, 0, 5);
} catch {}
try {
buffer60.unmap();
} catch {}
let textureView140 = texture21.createView({dimension: '2d'});
try {
computePassEncoder5.setBindGroup(1, bindGroup40, new Uint32Array(397), 8, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer102, 'uint16', 6, 66);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 327, height: 1, depthOrArrayLayers: 21}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture153,
  mipLevel: 0,
  origin: {x: 100, y: 0, z: 12},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder115 = device0.createCommandEncoder({});
try {
renderPassEncoder15.setBindGroup(0, bindGroup57);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer85, 'uint32', 28, 52);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(5, buffer87);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup62 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 0, resource: {buffer: buffer37, size: 64}}],
});
let commandEncoder116 = device0.createCommandEncoder({});
let texture159 = device0.createTexture({
  size: [48, 48, 150],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder6.setIndexBuffer(buffer95, 'uint32', 4, 10);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer35, 4);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup38);
} catch {}
let bindGroup63 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 0, resource: {buffer: buffer79, size: 68}}],
});
let buffer108 = device0.createBuffer({
  size: 112,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let textureView141 = texture56.createView({label: '\ud7d1\ue46d\u0aca\u0781\ub58a\u{1f7f8}', arrayLayerCount: 1});
try {
renderPassEncoder8.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup19, new Uint32Array(830), 114, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer77, 'uint16', 14, 1);
} catch {}
try {
buffer106.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer7]);
} catch {}
try {
device0.queue.writeBuffer(buffer40, 48, new DataView(new ArrayBuffer(29452)), 1686, 8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 6, height: 6, depthOrArrayLayers: 18}
*/
{
  source: img1,
  origin: { x: 0, y: 3 },
  flipY: false,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'film', transfer: 'iec61966-2-1'} });
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let autogeneratedBindGroupLayout12 = pipeline4.getBindGroupLayout(0);
let commandEncoder117 = device0.createCommandEncoder({});
try {
renderPassEncoder27.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer35, 0, 4);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthReadOnly: true});
try {
renderPassEncoder17.setBindGroup(2, bindGroup46, [0, 0]);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup7);
} catch {}
let buffer109 = device0.createBuffer({size: 16, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
try {
renderPassEncoder24.setBindGroup(2, bindGroup16, new Uint32Array(5458), 458, 0);
} catch {}
try {
buffer58.unmap();
} catch {}
try {
commandEncoder105.copyTextureToTexture({
  texture: texture148,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture157,
  mipLevel: 0,
  origin: {x: 34, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let promise18 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4', constants: {}}});
let imageData17 = new ImageData(44, 20);
let texture160 = device0.createTexture({size: [1310], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
let textureView142 = texture104.createView({dimension: '2d', format: 'astc-10x6-unorm-srgb', mipLevelCount: 1});
try {
computePassEncoder16.setBindGroup(2, bindGroup55, new Uint32Array(1285), 42, 0);
} catch {}
let pipeline27 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule5, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE}]},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 8,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint8x2', offset: 0, shaderLocation: 12},
          {format: 'snorm16x4', offset: 0, shaderLocation: 1},
          {format: 'uint16x4', offset: 0, shaderLocation: 11},
          {format: 'uint16x4', offset: 0, shaderLocation: 15},
          {format: 'float16x4', offset: 0, shaderLocation: 3},
          {format: 'sint8x4', offset: 0, shaderLocation: 13},
          {format: 'float32x2', offset: 0, shaderLocation: 8},
          {format: 'sint32x2', offset: 0, shaderLocation: 14},
          {format: 'float32x2', offset: 0, shaderLocation: 4},
          {format: 'float32', offset: 0, shaderLocation: 6},
          {format: 'unorm8x2', offset: 0, shaderLocation: 9},
          {format: 'snorm16x4', offset: 0, shaderLocation: 0},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10},
          {format: 'float32', offset: 0, shaderLocation: 2},
          {format: 'uint16x2', offset: 0, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', unclippedDepth: true},
});
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte240m', transfer: 'smpte240m'} });
let bindGroup64 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 20, resource: {buffer: buffer77, offset: 0}}],
});
let texture161 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 10},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder28 = commandEncoder83.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 133,
  clearValue: { r: -713.6, g: -872.6, b: -486.5, a: 352.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let sampler22 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.45,
  compare: 'less-equal',
  maxAnisotropy: 1,
});
try {
renderPassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(5713), 993, 0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup37, new Uint32Array(1200), 12, 0);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
buffer93.unmap();
} catch {}
let bindGroup65 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: {buffer: buffer6}}, {binding: 0, resource: {buffer: buffer88}}],
});
let commandEncoder118 = device0.createCommandEncoder({});
try {
computePassEncoder12.setBindGroup(2, bindGroup31, new Uint32Array(2019), 202, 0);
} catch {}
try {
renderBundleEncoder29.setBindGroup(1, bindGroup1, []);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup15, new Uint32Array(1167), 216, 0);
} catch {}
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpteSt4281', transfer: 'gamma28curve'} });
let bindGroup66 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 1, resource: {buffer: buffer105, size: 128}}],
});
let textureView143 = texture0.createView({dimension: '2d-array', aspect: 'all'});
let texture162 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder9.setBindGroup(1, bindGroup61, new Uint32Array(2606), 42, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer84, 60);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(2, buffer35, 8, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer39, 'uint32', 196, 26);
} catch {}
try {
  await buffer10.mapAsync(GPUMapMode.READ);
} catch {}
let commandEncoder119 = device0.createCommandEncoder({});
let texture163 = device0.createTexture({
  size: [8, 8, 13],
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder29 = commandEncoder47.beginRenderPass({
  colorAttachments: [{
  view: textureView38,
  clearValue: { r: 920.1, g: 501.2, b: 624.3, a: 570.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder6.drawIndexedIndirect(buffer101, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer76, 100);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer60, 'uint16', 70, 3);
} catch {}
try {
commandEncoder90.clearBuffer(buffer0);
} catch {}
try {
commandEncoder60.resolveQuerySet(querySet0, 50, 1, buffer58, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 6, height: 6, depthOrArrayLayers: 18}
*/
{
  source: videoFrame23,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout13 = pipeline18.getBindGroupLayout(1);
let commandEncoder120 = device0.createCommandEncoder({});
let texture164 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder8.setBindGroup(0, bindGroup13, new Uint32Array(200), 41, 0);
} catch {}
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer84, 116);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer100, 'uint32', 40, 1);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer40, 0, 1);
} catch {}
try {
renderBundleEncoder5.draw(282, 1, 147_330_726);
} catch {}
try {
renderBundleEncoder14.drawIndexedIndirect(buffer83, 4);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline11);
} catch {}
let arrayBuffer6 = buffer10.getMappedRange(0, 0);
try {
buffer55.unmap();
} catch {}
let commandEncoder121 = device0.createCommandEncoder({});
let textureView144 = texture36.createView({dimension: '2d-array'});
let externalTexture15 = device0.importExternalTexture({source: videoFrame8});
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let recycledExplicitBindGroupLayout1 = pipeline16.getBindGroupLayout(1);
let texture165 = device0.createTexture({
  size: [1310, 1, 17],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture166 = device0.createTexture({size: {width: 12}, dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.COPY_SRC});
let texture167 = gpuCanvasContext4.getCurrentTexture();
try {
renderPassEncoder16.setBindGroup(3, bindGroup39, new Uint32Array(3647), 417, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer24, 'uint16', 10, 1);
} catch {}
try {
renderBundleEncoder31.setBindGroup(1, bindGroup0, new Uint32Array(7261), 2_171, 0);
} catch {}
try {
commandEncoder71.copyTextureToTexture({
  texture: texture97,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 6},
  aspect: 'all',
},
{
  texture: texture83,
  mipLevel: 0,
  origin: {x: 8, y: 2, z: 0},
  aspect: 'all',
},
{width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING, colorSpace: 'srgb'});
} catch {}
let commandEncoder122 = device0.createCommandEncoder();
let textureView145 = texture163.createView({dimension: '2d', baseArrayLayer: 1});
try {
renderPassEncoder6.drawIndexedIndirect(buffer108, 12);
} catch {}
try {
buffer31.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 163, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 10, y: 2 },
  flipY: true,
}, {
  texture: texture164,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 68, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup67 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 9, resource: externalTexture10},
    {binding: 0, resource: textureView145},
    {binding: 2, resource: textureView119},
    {binding: 20, resource: {buffer: buffer60}},
  ],
});
let buffer110 = device0.createBuffer({size: 360, usage: GPUBufferUsage.COPY_DST});
let commandEncoder123 = device0.createCommandEncoder({});
let textureView146 = texture106.createView({baseArrayLayer: 0});
let renderBundle17 = renderBundleEncoder14.finish({});
try {
computePassEncoder11.setBindGroup(0, bindGroup4, new Uint32Array(571), 13, 0);
} catch {}
try {
renderBundleEncoder31.setIndexBuffer(buffer83, 'uint16', 0, 81);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let commandEncoder124 = device0.createCommandEncoder({});
let textureView147 = texture134.createView({});
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer85, 'uint32', 16, 12);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let textureView148 = texture71.createView({dimension: '2d', baseArrayLayer: 3});
try {
computePassEncoder13.setBindGroup(3, bindGroup3, new Uint32Array(903), 190, 0);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(7, buffer106);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline27);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder20.setBindGroup(2, bindGroup59, []);
} catch {}
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer4, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer93, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline7);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
document.body.append(img0);
try {
renderPassEncoder28.setIndexBuffer(buffer24, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder30.setBindGroup(3, bindGroup17);
} catch {}
try {
device0.queue.writeBuffer(buffer84, 52, new DataView(new ArrayBuffer(2683)), 97, 8);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer1, 8);
} catch {}
let commandEncoder125 = device0.createCommandEncoder({});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 140});
let renderPassEncoder30 = commandEncoder71.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 91,
  clearValue: { r: 526.3, g: 922.4, b: 814.7, a: -8.642, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 112044001,
});
try {
renderPassEncoder23.setBindGroup(2, bindGroup9);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer4, 0);
} catch {}
document.body.append(img2);
let commandEncoder126 = device0.createCommandEncoder({label: '\ud366\udff9\u{1fcf0}\u92f2\u{1f830}\u764f\uf32a\u1b3f\u43e1\u{1fe0d}\u086c'});
let texture168 = device0.createTexture({
  size: [6],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder13.setBindGroup(0, bindGroup46, [0, 0]);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup38);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer95, 8);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(0, buffer7, 28, 9);
} catch {}
try {
buffer11.unmap();
} catch {}
let commandEncoder127 = device0.createCommandEncoder();
let textureView149 = texture152.createView({dimension: 'cube-array', aspect: 'all', arrayLayerCount: 6});
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer106, 20, 0);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(2, buffer45, 4, 10);
} catch {}
let pipeline28 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}});
canvas1.height = 252;
try {
computePassEncoder6.setBindGroup(3, bindGroup1, new Uint32Array(1430), 203, 0);
} catch {}
try {
renderPassEncoder25.beginOcclusionQuery(90);
} catch {}
try {
renderPassEncoder25.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer84, 28);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(3, buffer102, 0);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline21);
} catch {}
try {
computePassEncoder17.insertDebugMarker('\uddae');
} catch {}
try {
device0.queue.writeBuffer(buffer44, 12, new Float32Array(6696).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.431)), 288, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 6, height: 6, depthOrArrayLayers: 18}
*/
{
  source: img3,
  origin: { x: 1, y: 32 },
  flipY: false,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let texture169 = device0.createTexture({
  size: {width: 12},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let texture170 = gpuCanvasContext4.getCurrentTexture();
let textureView150 = texture91.createView({});
try {
renderPassEncoder6.drawIndirect(buffer61, 16);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer102, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(1, bindGroup7, new Uint32Array(3199), 716, 0);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer51, 'uint32', 8, 24);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline11);
} catch {}
let pipeline29 = await device0.createRenderPipelineAsync({
  label: '\ufc02\ud901\u03d9\u0a5c\u3ba9\ue084\u{1fbe4}\u66c9\u300b\ua4bc',
  layout: pipelineLayout2,
  multisample: {count: 1, mask: 0x25c24e6b},
  fragment: {module: shaderModule3, entryPoint: 'fragment4', targets: [{format: 'rg8uint', writeMask: 0}]},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 8,
        attributes: [
          {format: 'uint8x2', offset: 0, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 15},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 16,
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 9},
          {format: 'unorm8x2', offset: 2, shaderLocation: 12},
          {format: 'unorm16x2', offset: 0, shaderLocation: 1},
          {format: 'uint8x2', offset: 2, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
await gc();
try {
computePassEncoder21.setBindGroup(1, bindGroup29);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup7, new Uint32Array(370), 6, 0);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder30.setPipeline(pipeline21);
} catch {}
let commandEncoder128 = device0.createCommandEncoder({label: '\udba9\u08df\uc20b\u8699\u0b81'});
let textureView151 = texture14.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder16.drawIndexed(0, 1, 0, 189_424_692);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(6, buffer75, 0, 37);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 72, new DataView(new ArrayBuffer(51668)), 144, 36);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(61); };
} catch {}
let autogeneratedBindGroupLayout14 = pipeline10.getBindGroupLayout(0);
let buffer111 = device0.createBuffer({
  size: 453,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
});
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer94, 0);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline18);
} catch {}
try {
commandEncoder108.copyTextureToTexture({
  texture: texture146,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture89,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let pipeline30 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, constants: {}}});
let texture171 = device0.createTexture({size: [48], dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder16.drawIndirect(buffer48, 8);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(1, buffer35);
} catch {}
let pipeline31 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 1, mask: 0x2a5ba1c5},
  fragment: {module: shaderModule5, constants: {}, targets: [{format: 'rg8uint'}]},
  vertex: {module: shaderModule3, entryPoint: 'vertex2', constants: {}, buffers: []},
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: false,
},
});
try {
computePassEncoder9.setBindGroup(2, bindGroup16);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder16.drawIndexed(0, 1, 0, -1_808_977_217);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer52, 12);
} catch {}
try {
renderBundleEncoder33.setBindGroup(1, bindGroup15);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline29);
} catch {}
let bindGroup68 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout19,
  entries: [{binding: 0, resource: {buffer: buffer60}}, {binding: 1, resource: {buffer: buffer7, offset: 0}}],
});
let commandEncoder129 = device0.createCommandEncoder({});
let textureView152 = texture51.createView({});
try {
computePassEncoder6.setBindGroup(0, bindGroup33);
} catch {}
try {
renderPassEncoder16.drawIndexed(0, 1, 0, 600_039_094);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer94, 4);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer76, 324);
} catch {}
try {
buffer14.unmap();
} catch {}
document.body.prepend(img3);
let commandEncoder130 = device0.createCommandEncoder({});
let textureView153 = texture91.createView({format: 'rg8uint', baseArrayLayer: 0});
try {
renderPassEncoder17.setBindGroup(1, bindGroup56, new Uint32Array(2916), 191, 0);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer42, 8);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline26);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 6, height: 6, depthOrArrayLayers: 18}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 5},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder131 = device0.createCommandEncoder({label: '\ub751\ue3a6\u56f7\ucc11\u07ba\u0f09\u018f\ubbbf'});
let texture172 = device0.createTexture({
  size: [48, 48, 150],
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView154 = texture36.createView({mipLevelCount: 1});
let externalTexture16 = device0.importExternalTexture({source: videoFrame17});
try {
computePassEncoder1.setBindGroup(1, bindGroup67);
} catch {}
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer63, 0);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer62, 28);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(3, buffer41);
} catch {}
let recycledExplicitBindGroupLayout2 = pipeline17.getBindGroupLayout(2);
let buffer112 = device0.createBuffer({
  size: 146,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
try {
renderPassEncoder6.drawIndirect(buffer52, 180);
} catch {}
try {
renderBundleEncoder33.setBindGroup(2, bindGroup19, new Uint32Array(743), 72, 0);
} catch {}
try {
renderBundleEncoder34.insertDebugMarker('\ue0fe');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(47).fill(3), /* required buffer size: 47 */
{offset: 47}, {width: 697, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder132 = device0.createCommandEncoder({});
let textureView155 = texture138.createView({format: 'rgba32uint', arrayLayerCount: 1});
try {
renderPassEncoder8.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer112, 8);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer42, 4);
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
try {
renderPassEncoder3.setBindGroup(2, bindGroup2, new Uint32Array(6168), 10, 0);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 64_432_442);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup47);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline1);
} catch {}
try {
buffer99.unmap();
} catch {}
try {
renderPassEncoder30.insertDebugMarker('\u005c');
} catch {}
try {
device0.queue.writeBuffer(buffer103, 0, new DataView(new Uint8Array(16250).map((_, i) => i).buffer), 3862, 0);
} catch {}
let imageData18 = new ImageData(60, 148);
let texture173 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 10},
  mipLevelCount: 3,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let sampler23 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 84.87,
  maxAnisotropy: 12,
});
try {
renderPassEncoder8.draw(61, 0, 331_472_262);
} catch {}
try {
renderPassEncoder16.drawIndexed(0, 314, 0, 88_734_176, 215_166_523);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer76, 180);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline17);
} catch {}
try {
commandEncoder119.copyTextureToBuffer({
  texture: texture149,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 116 widthInBlocks: 58 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3768 */
  offset: 3768,
  bytesPerRow: 4608,
  buffer: buffer56,
}, {width: 58, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
computePassEncoder13.setBindGroup(2, bindGroup61, new Uint32Array(406), 57, 0);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup47);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer95, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 0, new Uint16Array(221).map((_, i) => i + 7), 119, 0);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(37); };
} catch {}
let imageData19 = new ImageData(8, 80);
try {
renderPassEncoder26.setVertexBuffer(1, buffer55, 52);
} catch {}
let arrayBuffer7 = buffer10.getMappedRange(16, 4);
try {
device0.queue.writeBuffer(buffer77, 100, new Float32Array(10586).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.5431)), 634, 0);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(57); };
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
await gc();
let bindGroup69 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout12,
  entries: [{binding: 0, resource: {buffer: buffer32, offset: 0, size: 60}}],
});
let buffer113 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_SRC});
let renderPassEncoder31 = commandEncoder103.beginRenderPass({
  colorAttachments: [{
  view: textureView137,
  depthSlice: 8,
  clearValue: { r: -181.7, g: 371.0, b: -804.4, a: 264.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder8.drawIndexed(1, 0, 0, -1_966_658_172);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer111, 252);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer50, 0);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer52, 'uint32', 20, 51);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 12, new DataView(new ArrayBuffer(78524)), 663, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture153,
  mipLevel: 1,
  origin: {x: 13, y: 0, z: 6},
  aspect: 'all',
}, new Uint8Array(240_148).fill(123), /* required buffer size: 240_148 */
{offset: 36, bytesPerRow: 698, rowsPerImage: 43}, {width: 35, height: 0, depthOrArrayLayers: 9});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture174 = gpuCanvasContext3.getCurrentTexture();
try {
computePassEncoder17.setBindGroup(1, bindGroup9, new Uint32Array(962), 62, 0);
} catch {}
try {
renderPassEncoder8.draw(145, 0, 1_611_284_484);
} catch {}
try {
renderBundleEncoder36.setBindGroup(0, bindGroup62, new Uint32Array(819), 13, 0);
} catch {}
try {
renderPassEncoder6.draw(0, 0, 0);
} catch {}
try {
renderPassEncoder16.drawIndexed(0, 430, 0, 161_548_825, 519_170_226);
} catch {}
try {
renderBundleEncoder22.drawIndexedIndirect(buffer112, 36);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer91, 'uint16', 104, 234);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1310, height: 1, depthOrArrayLayers: 13}
*/
{
  source: imageData9,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture147,
  mipLevel: 0,
  origin: {x: 333, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView156 = texture163.createView({dimension: '2d', baseArrayLayer: 2});
let textureView157 = texture129.createView({label: '\u0e47\ubcd2\u2d3b\u{1fd7f}\u{1f9c9}\u09ca\u6b02\u0178', dimension: '2d-array'});
try {
renderPassEncoder16.drawIndirect(buffer95, 20);
} catch {}
try {
renderBundleEncoder32.setBindGroup(3, bindGroup5);
} catch {}
try {
renderBundleEncoder22.drawIndexedIndirect(buffer63, 0);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer1, 'uint32', 116, 71);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(5, buffer84);
} catch {}
let commandEncoder133 = device0.createCommandEncoder();
try {
computePassEncoder13.setBindGroup(0, bindGroup66);
} catch {}
try {
renderPassEncoder16.draw(588, 27, 98_431_162, 219_257_274);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer108, 'uint16', 42, 16);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(6, buffer87, 0, 80);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup35);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer94, 40);
} catch {}
try {
buffer96.unmap();
} catch {}
try {
commandEncoder99.clearBuffer(buffer87);
} catch {}
try {
renderBundleEncoder28.insertDebugMarker('\u9bf3');
} catch {}
try {
device0.queue.writeBuffer(buffer110, 104, new Float32Array(14813).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.240)), 3557, 8);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1310, height: 1, depthOrArrayLayers: 13}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture147,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline32 = await promise18;
let pipeline33 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule1, targets: [{format: 'rg8uint'}]},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 96,
        attributes: [
          {format: 'unorm8x4', offset: 0, shaderLocation: 12},
          {format: 'snorm8x2', offset: 0, shaderLocation: 15},
          {format: 'float32', offset: 20, shaderLocation: 10},
          {format: 'sint16x2', offset: 20, shaderLocation: 9},
          {format: 'uint32x2', offset: 32, shaderLocation: 2},
          {format: 'uint32x4', offset: 12, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 48, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true},
});
document.body.append(img0);
let bindGroup70 = device0.createBindGroup({
  label: '\u1a32\u8144\u0abe',
  layout: veryExplicitBindGroupLayout11,
  entries: [{binding: 0, resource: {buffer: buffer105, offset: 0}}, {binding: 1, resource: {buffer: buffer105}}],
});
try {
computePassEncoder1.setBindGroup(3, bindGroup9, new Uint32Array(1787), 154, 0);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer62, 24);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer108);
} catch {}
try {
buffer1.unmap();
} catch {}
let buffer114 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let externalTexture17 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'display-p3'});
try {
renderPassEncoder16.drawIndexedIndirect(buffer1, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer39, 36, 26);
} catch {}
try {
commandEncoder55.copyBufferToBuffer(buffer93, 0, buffer106, 0, 0);
} catch {}
let buffer115 = device0.createBuffer({size: 187, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let textureView158 = texture123.createView({dimension: '2d-array'});
try {
computePassEncoder13.setBindGroup(0, bindGroup26, new Uint32Array(1065), 89, 0);
} catch {}
try {
renderPassEncoder6.draw(0, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer83, 16);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer111, 16);
} catch {}
let buffer116 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder134 = device0.createCommandEncoder({});
let textureView159 = texture4.createView({baseArrayLayer: 4, arrayLayerCount: 4});
try {
renderPassEncoder6.drawIndexedIndirect(buffer62, 4);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer83, 8);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer43, 'uint32', 20, 4);
} catch {}
try {
renderBundleEncoder22.drawIndexed(2, 0, 0, -1_909_096_895);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline29);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 372, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(121).fill(49), /* required buffer size: 121 */
{offset: 121}, {width: 137, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder16.setBindGroup(1, bindGroup13, new Uint32Array(1996), 64, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup47);
} catch {}
try {
renderPassEncoder8.draw(94, 0, 300_034_892);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 117_594_655);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer52, 52);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup15);
} catch {}
try {
renderBundleEncoder33.setBindGroup(0, bindGroup34, new Uint32Array(603), 257, 0);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(1, buffer115, 12);
} catch {}
try {
commandEncoder114.clearBuffer(buffer60);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 44, new Float32Array(4779).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2282)), 505, 0);
} catch {}
let commandEncoder135 = device0.createCommandEncoder({});
let renderBundle18 = renderBundleEncoder22.finish({});
try {
renderPassEncoder31.setBindGroup(0, bindGroup55, new Uint32Array(5022), 896, 0);
} catch {}
try {
renderPassEncoder8.draw(83, 0, 273_884_331);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer108, 44);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer92, 'uint32', 0, 2);
} catch {}
try {
renderBundleEncoder33.setPipeline(pipeline12);
} catch {}
let arrayBuffer8 = buffer10.getMappedRange(8, 0);
try {
  await promise19;
} catch {}
let commandEncoder136 = device0.createCommandEncoder({});
let texture175 = device0.createTexture({size: [24], dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder21.setBindGroup(2, bindGroup0, new Uint32Array(1767), 82, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer108, 20);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup26, new Uint32Array(117), 30, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let canvas5 = document.createElement('canvas');
try {
renderBundleEncoder30.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(3, buffer51, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer111, 32, new DataView(new ArrayBuffer(600)), 3, 100);
} catch {}
let imageBitmap2 = await createImageBitmap(imageData18);
let autogeneratedBindGroupLayout15 = pipeline28.getBindGroupLayout(0);
let commandEncoder137 = device0.createCommandEncoder({});
try {
renderPassEncoder16.draw(10, 259, 932_376_761, 9_875_524);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 128_310_480, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer51, 4, 0);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline25);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 8, new DataView(new Uint8Array(35410).map((_, i) => i).buffer), 978, 52);
} catch {}
let pipeline34 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4, constants: {}}});
let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 79,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
  ],
});
let textureView160 = texture73.createView({mipLevelCount: 1});
try {
renderPassEncoder8.setBindGroup(1, bindGroup1, new Uint32Array(10000), 3_715, 0);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 2_461_440);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer94, 24);
} catch {}
try {
renderBundleEncoder29.setBindGroup(0, bindGroup70);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup13, new Uint32Array(867), 17, 0);
} catch {}
try {
commandEncoder50.clearBuffer(buffer60);
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0); };
} catch {}
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
    {
      binding: 71,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 102,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 191,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 211,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 294,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 706,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup64, new Uint32Array(831), 196, 0);
} catch {}
try {
renderPassEncoder16.draw(65, 13, 720_403_171, 50_700_909);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 400_443_726);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer63, 0);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer4, 4);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer14, 'uint16', 4, 0);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup70, []);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer25, 'uint16', 0, 1);
} catch {}
try {
commandEncoder75.copyTextureToTexture({
  texture: texture153,
  mipLevel: 0,
  origin: {x: 58, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture173,
  mipLevel: 1,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise20;
} catch {}
document.body.append(canvas0);
let texture176 = device0.createTexture({
  size: {width: 24, height: 24, depthOrArrayLayers: 60},
  mipLevelCount: 1,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture177 = device0.createTexture({
  size: [655, 1, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder16.drawIndirect(buffer61, 16);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer60, 'uint32', 92, 194);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup66, new Uint32Array(1807), 113, 0);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(7, buffer94, 0, 145);
} catch {}
let imageData20 = new ImageData(4, 52);
let commandEncoder138 = device0.createCommandEncoder({});
let textureView161 = texture176.createView({baseArrayLayer: 1, arrayLayerCount: 2});
try {
renderBundleEncoder29.setBindGroup(0, bindGroup68);
} catch {}
try {
buffer29.unmap();
} catch {}
try {
commandEncoder87.copyBufferToBuffer(buffer33, 0, buffer93, 0, 0);
} catch {}
let commandEncoder139 = device0.createCommandEncoder({});
try {
renderPassEncoder6.end();
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer83, 64);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer108, 28);
} catch {}
try {
renderBundleEncoder29.setBindGroup(2, bindGroup37, new Uint32Array(1316), 18, 0);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
document.body.append(canvas4);
let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({
  label: '\u17ef\uf3e9\ua9b9\ufb2c\u040e\u3268\uf67e',
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', minBindingSize: 20, hasDynamicOffset: false },
    },
  ],
});
let buffer117 = device0.createBuffer({size: 77, usage: GPUBufferUsage.INDEX});
let texture178 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 41},
  sampleCount: 1,
  format: 'rgba32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView162 = texture121.createView({dimension: '2d-array', mipLevelCount: 2});
try {
renderPassEncoder16.draw(203, 97, 195_567_155, 523_740_746);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 107_695_984);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer48, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer85, 'uint16', 110, 75);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline31);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 163, height: 1, depthOrArrayLayers: 10}
*/
{
  source: imageData11,
  origin: { x: 1, y: 27 },
  flipY: true,
}, {
  texture: texture173,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline35 = await device0.createRenderPipelineAsync({
  label: '\u{1f85c}\u0aa8\u190c\u9ce8',
  layout: 'auto',
  multisample: {count: 1, mask: 0x317c9e4a},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment6',
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 1340,
        attributes: [
          {format: 'float32', offset: 64, shaderLocation: 0},
          {format: 'unorm8x2', offset: 214, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 512, shaderLocation: 8},
          {format: 'float16x4', offset: 380, shaderLocation: 1},
          {format: 'uint32x4', offset: 568, shaderLocation: 15},
          {format: 'unorm10-10-10-2', offset: 224, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 220, shaderLocation: 10},
          {format: 'sint8x4', offset: 156, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 56,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32', offset: 0, shaderLocation: 2},
          {format: 'sint8x2', offset: 0, shaderLocation: 14},
          {format: 'uint8x4', offset: 0, shaderLocation: 5},
          {format: 'sint16x2', offset: 0, shaderLocation: 12},
          {format: 'uint16x4', offset: 0, shaderLocation: 11},
          {format: 'float32x2', offset: 20, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 452,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 32, shaderLocation: 4}],
      },
    ],
  },
  primitive: {unclippedDepth: true},
});
try {
gpuCanvasContext3.unconfigure();
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte432', transfer: 'iec6196624'} });
let bindGroup71 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 20, resource: {buffer: buffer60, offset: 0}}],
});
let commandBuffer11 = commandEncoder16.finish();
let texture179 = device0.createTexture({
  size: [8],
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture180 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 18},
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder8.setBindGroup(0, bindGroup22);
} catch {}
try {
renderPassEncoder25.setBindGroup(3, bindGroup26);
} catch {}
try {
renderPassEncoder16.draw(379, 106, 562_325_010, 349_645_052);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer42, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer102, 'uint32', 52, 39);
} catch {}
try {
device0.queue.writeBuffer(buffer39, 240, new Uint32Array(2551).map((_, i) => i * 10), 601, 12);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 8, depthOrArrayLayers: 13}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture158,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline36 = await promise5;
let commandEncoder140 = device0.createCommandEncoder({});
let textureView163 = texture138.createView({dimension: '2d-array'});
try {
renderPassEncoder16.drawIndexed(1, 23, 0, 334_042_009, 1_030_587_679);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer1, 56);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline3);
} catch {}
try {
buffer31.unmap();
} catch {}
let texture181 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 18},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture182 = device0.createTexture({
  size: [8, 8, 8],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder32 = commandEncoder76.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 38,
  clearValue: { r: -375.6, g: -774.6, b: 562.7, a: 204.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet2,
  maxDrawCount: 122064064,
});
try {
computePassEncoder19.setBindGroup(0, bindGroup33, new Uint32Array(345), 94, 0);
} catch {}
try {
renderPassEncoder26.beginOcclusionQuery(129);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer55, 0, 6);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let bindGroup72 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 79, resource: textureView46},
    {binding: 0, resource: textureView110},
    {binding: 2, resource: {buffer: buffer72}},
  ],
});
let texture183 = device0.createTexture({
  size: {width: 12},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView164 = texture120.createView({dimension: 'cube-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 6});
let sampler24 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 60.24});
let externalTexture18 = device0.importExternalTexture({source: videoFrame11, colorSpace: 'display-p3'});
try {
renderPassEncoder8.draw(103, 0, 1_987_470_548);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let textureView165 = texture181.createView({aspect: 'all'});
try {
computePassEncoder9.setBindGroup(1, bindGroup70, new Uint32Array(2057), 20, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer111, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture184 = device0.createTexture({
  size: {width: 1310},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture185 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler25 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 87.73,
  lodMaxClamp: 88.48,
  compare: 'less-equal',
  maxAnisotropy: 2,
});
try {
computePassEncoder7.setBindGroup(1, bindGroup2, new Uint32Array(2059), 686, 0);
} catch {}
try {
renderPassEncoder16.draw(57, 11, 1_702_664_773, 3_214_444_209);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer115, 0);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 40, height: 1, depthOrArrayLayers: 10}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture173,
  mipLevel: 2,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let img4 = await imageWithData(102, 17, '#10101010', '#20202020');
let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470bg', transfer: 'pq'} });
let textureView166 = texture184.createView({});
let texture186 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 1},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView167 = texture112.createView({mipLevelCount: 1});
try {
renderPassEncoder8.draw(83, 0, 44_614_145);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer1, 24);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder21.setBindGroup(1, bindGroup8, new Uint32Array(1603), 114, 0);
} catch {}
let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 1, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 288,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let texture187 = device0.createTexture({
  size: [8, 8, 13],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder8.drawIndirect(buffer108, 16);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer95, 'uint16', 26, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline21);
} catch {}
try {
buffer115.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture124,
  mipLevel: 3,
  origin: {x: 7, y: 0, z: 10},
  aspect: 'all',
}, new Uint8Array(587).fill(4), /* required buffer size: 587 */
{offset: 291, bytesPerRow: 37, rowsPerImage: 8}, {width: 7, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
renderPassEncoder16.drawIndexed(1, 223, 0, 132_629_323, 539_743_407);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer95, 8);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(0, buffer102, 0, 11);
} catch {}
try {
commandEncoder91.copyTextureToBuffer({
  texture: texture91,
  mipLevel: 0,
  origin: {x: 37, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5402 */
  offset: 5402,
  bytesPerRow: 4608,
  buffer: buffer56,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline37 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
let gpuCanvasContext6 = canvas5.getContext('webgpu');
try {
renderPassEncoder25.beginOcclusionQuery(137);
} catch {}
try {
renderPassEncoder16.draw(52, 35, 842_707_129, 1_061_748_237);
} catch {}
try {
renderPassEncoder16.drawIndexed(1, 452, 0, 722_730_905, 322_531);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer96, 4);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline35);
} catch {}
let commandEncoder141 = device0.createCommandEncoder({});
let texture188 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder16.draw(39, 42, 313_555_071, 530_921_205);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer115, 28);
} catch {}
try {
renderBundleEncoder34.setBindGroup(0, bindGroup37);
} catch {}
try {
buffer91.unmap();
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let sampler26 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder3.setBindGroup(1, bindGroup40, new Uint32Array(2744), 348, 0);
} catch {}
try {
renderPassEncoder31.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder30.setBindGroup(3, bindGroup27, new Uint32Array(4948), 230, 0);
} catch {}
try {
renderPassEncoder8.draw(557, 0, 80_125_957);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer52, 64);
} catch {}
try {
buffer94.unmap();
} catch {}
let commandEncoder142 = device0.createCommandEncoder();
let externalTexture19 = device0.importExternalTexture({source: videoFrame19});
try {
renderPassEncoder10.setStencilReference(1233);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup12);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer83, 'uint32', 0, 1);
} catch {}
let commandEncoder143 = device0.createCommandEncoder();
let texture189 = device0.createTexture({
  size: [48, 48, 19],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder19.setBindGroup(3, bindGroup1, new Uint32Array(691), 98, 0);
} catch {}
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.drawIndexed(1, 59, 0, -2_141_594_115, 720_481_421);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer84, 96);
} catch {}
let bindGroup73 = device0.createBindGroup({layout: autogeneratedBindGroupLayout14, entries: [{binding: 0, resource: {buffer: buffer49}}]});
let textureView168 = texture163.createView({dimension: '2d', baseArrayLayer: 2});
let texture190 = device0.createTexture({
  size: {width: 655, height: 1, depthOrArrayLayers: 65},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder8.setBindGroup(2, bindGroup2, new Uint32Array(1201), 634, 0);
} catch {}
try {
renderPassEncoder28.setBlendConstant({ r: 366.1, g: -844.5, b: 593.7, a: 683.9, });
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, -1_776_345_541);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer52, 56);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup55);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer93, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(3, buffer40, 0);
} catch {}
try {
computePassEncoder21.insertDebugMarker('\u5521');
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.writeBuffer(buffer47, 0, new Float32Array(11258).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.593)), 8039, 0);
} catch {}
document.body.prepend(canvas3);
let videoFrame29 = new VideoFrame(canvas0, {timestamp: 0});
try {
globalThis.someLabel = sampler5.label;
} catch {}
let texture191 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 1},
  format: 'astc-6x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder32.beginOcclusionQuery(132);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer83, 28);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u62d5');
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let imageBitmap3 = await createImageBitmap(offscreenCanvas0);
let commandEncoder144 = device0.createCommandEncoder({});
let renderPassEncoder33 = commandEncoder102.beginRenderPass({
  colorAttachments: [{view: textureView82, depthSlice: 46, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 7000120,
});
let renderBundleEncoder38 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
try {
computePassEncoder17.setBindGroup(2, bindGroup9, new Uint32Array(546), 84, 0);
} catch {}
try {
renderPassEncoder27.setBindGroup(2, bindGroup31, new Uint32Array(903), 39, 0);
} catch {}
try {
renderBundleEncoder28.setBindGroup(3, bindGroup40, new Uint32Array(4209), 1_690, 0);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer25, 4, new Float32Array(4418).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4395)), 36, 0);
} catch {}
let buffer118 = device0.createBuffer({
  size: 152,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder145 = device0.createCommandEncoder({});
let texture192 = device0.createTexture({
  size: {width: 655},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder13.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder25.setBlendConstant({ r: 177.1, g: 902.1, b: -782.0, a: 203.8, });
} catch {}
try {
renderPassEncoder16.draw(70, 44, 26_254_585, 639_213_133);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer95, 24);
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup38);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer102, 'uint32', 12, 43);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline33);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(60);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer42, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup66);
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup13, new Uint32Array(3618), 94, 0);
} catch {}
try {
commandEncoder132.copyTextureToBuffer({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 416 */
  offset: 416,
  bytesPerRow: 512,
  buffer: buffer39,
}, {width: 6, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture11.label;
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout18,
  entries: [{binding: 0, resource: {buffer: buffer37, size: 104}}, {binding: 1, resource: {buffer: buffer6}}],
});
let buffer119 = device0.createBuffer({
  size: 100,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView169 = texture98.createView({mipLevelCount: 1});
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 157_856_656, 0);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer83, 96);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer76, 56);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(0, buffer105, 28, 28);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let pipeline38 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex1',
    buffers: [
      {
        arrayStride: 816,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 36, shaderLocation: 0},
          {format: 'snorm16x2', offset: 16, shaderLocation: 8},
          {format: 'snorm8x4', offset: 300, shaderLocation: 15},
          {format: 'snorm16x4', offset: 40, shaderLocation: 10},
          {format: 'unorm8x2', offset: 248, shaderLocation: 7},
          {format: 'uint8x2', offset: 80, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 324, shaderLocation: 2},
          {format: 'uint32x4', offset: 32, shaderLocation: 13},
          {format: 'float32x4', offset: 156, shaderLocation: 3},
          {format: 'uint32', offset: 80, shaderLocation: 5},
          {format: 'uint8x4', offset: 4, shaderLocation: 12},
          {format: 'uint32x3', offset: 172, shaderLocation: 1},
        ],
      },
    ],
  },
});
let buffer120 = device0.createBuffer({
  size: 112,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture193 = gpuCanvasContext5.getCurrentTexture();
try {
renderPassEncoder32.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(2, buffer118, 4);
} catch {}
try {
computePassEncoder13.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, -2_122_700_909);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer91, 'uint32', 164, 115);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer57, 0, 1);
} catch {}
try {
renderBundleEncoder30.setPipeline(pipeline15);
} catch {}
try {
device0.queue.writeBuffer(buffer106, 8, new DataView(new Uint8Array(7755).map((_, i) => i).buffer), 831, 0);
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
let buffer121 = device0.createBuffer({
  size: 528,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView170 = texture180.createView({baseArrayLayer: 0});
try {
computePassEncoder7.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder25.setBindGroup(1, bindGroup69, new Uint32Array(1021), 71, 0);
} catch {}
try {
renderPassEncoder25.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.draw(36, 0, 941_601_630);
} catch {}
try {
renderPassEncoder16.drawIndexed(1, 157, 0, 395_344_085, 611_452_873);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer76, 84);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer91, 'uint32', 28, 36);
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline7);
} catch {}
try {
commandEncoder101.clearBuffer(buffer29);
} catch {}
try {
device0.queue.writeBuffer(buffer96, 136, new DataView(new ArrayBuffer(36492)), 435, 0);
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
let commandEncoder146 = device0.createCommandEncoder({});
let textureView171 = texture115.createView({label: '\u0288\u3987\ubaa7\u04b0\ua128\u0f1d\ua4ea\u4eff'});
let texture194 = device0.createTexture({
  size: {width: 1310},
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(2, buffer108, 20);
} catch {}
let textureView172 = texture176.createView({format: 'rg32sint', mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 22});
let textureView173 = texture189.createView({dimension: '2d', baseArrayLayer: 6});
try {
renderPassEncoder16.draw(156, 25, 168_682_718, 515_899_319);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer77, 'uint32', 164, 20);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(1, buffer2, 0, 1);
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline33);
} catch {}
try {
commandEncoder108.clearBuffer(buffer103);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 8},
  aspect: 'all',
}, new Uint8Array(101).fill(96), /* required buffer size: 101 */
{offset: 101}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
document.body.append(img1);
let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'log'} });
try {
computePassEncoder19.label = '\ub3ee\u96b3\u0bb7\u35ea\u9b59';
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 808_076_550, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer101, 12);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(3, buffer120, 0, 38);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer92, 'uint16', 2, 1);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(3, buffer119, 0, 7);
} catch {}
let promise23 = device0.queue.onSubmittedWorkDone();
let texture195 = device0.createTexture({size: {width: 24}, dimension: '1d', format: 'rg16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder16.drawIndexedIndirect(buffer76, 72);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer91, 'uint16', 46, 44);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(1, buffer94, 36, 0);
} catch {}
try {
commandEncoder98.copyTextureToTexture({
  texture: texture126,
  mipLevel: 0,
  origin: {x: 8, y: 38, z: 14},
  aspect: 'all',
},
{
  texture: texture22,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let sampler27 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  lodMaxClamp: 94.54,
});
try {
renderPassEncoder23.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder8.draw(172, 0, 107_970_774);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer1, 132);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer108, 'uint32', 16, 20);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer52, 'uint32', 108, 5);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
  await promise23;
} catch {}
await gc();
let buffer122 = device0.createBuffer({label: '\u56bc\u{1f654}', size: 44, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder147 = device0.createCommandEncoder({});
let textureView174 = texture100.createView({dimension: '2d-array'});
try {
renderPassEncoder8.drawIndirect(buffer76, 0);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(4, buffer51, 16, 5);
} catch {}
try {
device0.queue.writeBuffer(buffer118, 56, new Float32Array(39255).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.705)), 9863, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer123 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture196 = device0.createTexture({
  label: '\uca4a\u{1fd35}',
  size: [1310, 1, 10],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder23.drawIndirect(buffer83, 12);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
let imageData21 = new ImageData(48, 72);
let buffer124 = device0.createBuffer({
  size: 219,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView175 = texture196.createView({dimension: '2d', format: 'rgba16uint', baseArrayLayer: 3});
let texture197 = gpuCanvasContext1.getCurrentTexture();
try {
renderPassEncoder8.drawIndexedIndirect(buffer52, 4);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer60, 'uint16', 152, 82);
} catch {}
try {
renderBundleEncoder38.setVertexBuffer(0, buffer124, 8);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 56, new Uint32Array(1202).map((_, i) => i * 8), 139, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture198 = gpuCanvasContext2.getCurrentTexture();
let textureView176 = texture87.createView({baseArrayLayer: 0});
try {
computePassEncoder10.setBindGroup(3, bindGroup5, new Uint32Array(1354), 3, 0);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer120, 4);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer93, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer118, 0, 14);
} catch {}
try {
commandEncoder56.clearBuffer(buffer45);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 223_437_050);
} catch {}
try {
renderPassEncoder23.drawIndexedIndirect(buffer61, 4);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(4, buffer105, 0, 23);
} catch {}
let commandEncoder148 = device0.createCommandEncoder();
let sampler28 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'nearest', lodMaxClamp: 56.42});
try {
computePassEncoder22.setPipeline(pipeline36);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup9, new Uint32Array(726), 204, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle1]);
} catch {}
let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'bt2020_12bit'} });
try {
renderPassEncoder30.setBindGroup(1, bindGroup72);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer40, 8);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer115, 4);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer112, 'uint16', 6, 22);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(1, buffer115, 20, 8);
} catch {}
try {
renderBundleEncoder32.setPipeline(pipeline21);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder149 = device0.createCommandEncoder({});
let texture199 = device0.createTexture({
  size: [1310, 1, 32],
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView177 = texture71.createView({aspect: 'all', arrayLayerCount: 2});
let renderPassEncoder34 = commandEncoder132.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: 803.8, g: -255.3, b: -743.6, a: -101.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder19.draw(344, 13, 1_036_165_418, 984_110_810);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer112, 12);
} catch {}
try {
buffer7.unmap();
} catch {}
let textureView178 = texture196.createView({dimension: '2d'});
try {
renderPassEncoder19.drawIndexedIndirect(buffer42, 12);
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(68); };
} catch {}
let videoFrame32 = new VideoFrame(videoFrame3, {timestamp: 0});
let textureView179 = texture179.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder16.setBindGroup(0, bindGroup42);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 807_245_856, 0);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer76, 76);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 44, new DataView(new ArrayBuffer(5756)), 195, 48);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 8, depthOrArrayLayers: 13}
*/
{
  source: offscreenCanvas0,
  origin: { x: 2, y: 16 },
  flipY: false,
}, {
  texture: texture158,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 13},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder23.draw(20, 0, 1_389_449_693);
} catch {}
try {
renderPassEncoder19.drawIndexed(0, 6, 0, 220_569_176, 1_599_475_965);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer91, 'uint16', 114, 6);
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline35);
} catch {}
try {
renderBundleEncoder37.setIndexBuffer(buffer39, 'uint16', 2, 340);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline38);
} catch {}
try {
commandEncoder55.copyTextureToBuffer({
  texture: texture77,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 320 */
  offset: 320,
  bytesPerRow: 34816,
  buffer: buffer29,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData22 = new ImageData(12, 148);
let buffer125 = device0.createBuffer({size: 584, usage: GPUBufferUsage.QUERY_RESOLVE});
let textureView180 = texture164.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
renderPassEncoder8.drawIndexed(1, 0, 0, -804_921_399, 0);
} catch {}
try {
renderPassEncoder23.drawIndexedIndirect(buffer63, 0);
} catch {}
let commandEncoder150 = device0.createCommandEncoder();
let texture200 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 22},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder15.setBindGroup(1, bindGroup64);
} catch {}
try {
renderPassEncoder19.draw(10, 333, 315_118_558, 555_081_734);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer4, 36);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer102, 'uint16', 76, 55);
} catch {}
try {
renderBundleEncoder33.setBindGroup(0, bindGroup37, new Uint32Array(3710), 898, 0);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer119, 'uint16', 18, 21);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(3, buffer86, 0, 0);
} catch {}
try {
commandEncoder116.copyTextureToTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 4},
  aspect: 'all',
},
{
  texture: texture22,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup75 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [
    {binding: 20, resource: {buffer: buffer77}},
    {binding: 0, resource: textureView10},
    {binding: 9, resource: externalTexture1},
  ],
});
let buffer126 = device0.createBuffer({size: 640, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder151 = device0.createCommandEncoder({});
let texture201 = gpuCanvasContext5.getCurrentTexture();
let textureView181 = texture133.createView({});
try {
computePassEncoder1.setBindGroup(1, bindGroup39, new Uint32Array(619), 83, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup69, new Uint32Array(1186), 111, 0);
} catch {}
try {
renderPassEncoder8.draw(150, 0, 3_520_933_900);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer42, 12);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer78, 'uint32', 4, 2);
} catch {}
let autogeneratedBindGroupLayout16 = pipeline19.getBindGroupLayout(0);
let texture202 = gpuCanvasContext5.getCurrentTexture();
let textureView182 = texture82.createView({});
try {
computePassEncoder21.setBindGroup(2, bindGroup66);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
document.body.append(img2);
let textureView183 = texture171.createView({dimension: '1d', arrayLayerCount: 1});
try {
renderPassEncoder8.drawIndexedIndirect(buffer50, 8);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer24, 'uint16', 6, 10);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let imageBitmap4 = await createImageBitmap(imageData13);
let bindGroup76 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 0, resource: {buffer: buffer7, offset: 0}},
    {binding: 1, resource: {buffer: buffer105, offset: 0, size: 136}},
  ],
});
let buffer127 = device0.createBuffer({size: 76, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder152 = device0.createCommandEncoder({});
let texture203 = device0.createTexture({
  size: [655, 1, 7],
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder5.setBindGroup(3, bindGroup24);
} catch {}
try {
renderPassEncoder23.drawIndexedIndirect(buffer112, 16);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer15, 'uint16', 2, 1);
} catch {}
try {
renderBundleEncoder32.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer102, 'uint32', 8, 22);
} catch {}
try {
commandEncoder139.copyTextureToBuffer({
  texture: texture99,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 114 */
  offset: 114,
  bytesPerRow: 17664,
  buffer: buffer0,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(3); };
} catch {}
try {
renderPassEncoder8.draw(70, 0, 857_020_317);
} catch {}
try {
renderPassEncoder19.drawIndexed(0, 16, 0, -2_064_671_965, 1_225_156_270);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer50, 40);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup40, new Uint32Array(467), 6, 0);
} catch {}
try {
commandEncoder55.copyTextureToBuffer({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 676 */
  offset: 676,
  rowsPerImage: 243,
  buffer: buffer29,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(14); };
} catch {}
try {
  await promise22;
} catch {}
let commandEncoder153 = device0.createCommandEncoder({});
let textureView184 = texture148.createView({});
try {
computePassEncoder21.setPipeline(pipeline30);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup12);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup70, new Uint32Array(875), 370, 0);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer112, 52);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer119, 28);
} catch {}
try {
renderBundleEncoder21.setBindGroup(2, bindGroup7);
} catch {}
try {
renderBundleEncoder21.drawIndirect(buffer4, 84);
} catch {}
try {
commandEncoder94.resolveQuerySet(querySet2, 7, 10, buffer99, 0);
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u074b');
} catch {}
let pipeline39 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule1, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 32,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 0, shaderLocation: 15},
          {format: 'float16x4', offset: 20, shaderLocation: 1},
          {format: 'sint16x2', offset: 0, shaderLocation: 9},
          {format: 'uint32x2', offset: 0, shaderLocation: 2},
          {format: 'snorm8x4', offset: 12, shaderLocation: 12},
          {format: 'uint32x2', offset: 0, shaderLocation: 11},
          {format: 'float32', offset: 4, shaderLocation: 10},
        ],
      },
    ],
  },
});
try {
computePassEncoder19.setBindGroup(3, bindGroup41, [0]);
} catch {}
try {
renderPassEncoder19.draw(206, 86, 422_956_613, 89_917_880);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 359_441_785);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer1, 12);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer108, 'uint16', 22, 40);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(7, buffer88);
} catch {}
try {
renderBundleEncoder21.draw(0, 213, 0, 1_133_712_775);
} catch {}
try {
renderBundleEncoder21.drawIndexedIndirect(buffer83, 12);
} catch {}
try {
renderBundleEncoder21.drawIndirect(buffer93, 0);
} catch {}
let commandEncoder154 = device0.createCommandEncoder({});
let texture204 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 1},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder35 = commandEncoder115.beginRenderPass({
  colorAttachments: [{
  view: textureView40,
  clearValue: { r: -343.4, g: -216.1, b: -560.4, a: 867.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet2,
});
let externalTexture20 = device0.importExternalTexture({source: videoFrame21});
try {
renderPassEncoder35.setBindGroup(0, bindGroup37, []);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(7, buffer86, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1310, height: 1, depthOrArrayLayers: 13}
*/
{
  source: imageBitmap1,
  origin: { x: 2, y: 8 },
  flipY: true,
}, {
  texture: texture147,
  mipLevel: 0,
  origin: {x: 79, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise21;
} catch {}
let commandEncoder155 = device0.createCommandEncoder({});
let texture205 = device0.createTexture({
  size: [8],
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle19 = renderBundleEncoder21.finish({});
try {
renderPassEncoder19.draw(1_000, 22, 371_749_963, 568_155_134);
} catch {}
try {
renderPassEncoder19.drawIndexed(0, 182, 0, 176_077_234, 373_215_693);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer94, 0);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer78, 'uint16', 2, 8);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(4, buffer94, 0);
} catch {}
try {
renderPassEncoder29.insertDebugMarker('\u{1fcd2}');
} catch {}
try {
device0.queue.writeBuffer(buffer106, 4, new Uint16Array(697).map((_, i) => i + 0), 97, 4);
} catch {}
let promise24 = device0.queue.onSubmittedWorkDone();
let textureView185 = texture182.createView({format: 'rgba32float', mipLevelCount: 1});
try {
renderPassEncoder19.draw(5, 21, 955_886_388, 376_734_532);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer63, 0);
} catch {}
let commandEncoder156 = device0.createCommandEncoder();
let textureView186 = texture42.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 23});
try {
renderPassEncoder23.drawIndexed(0, 0, 0, 157_126_180);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer112, 0);
} catch {}
try {
renderBundleEncoder38.setIndexBuffer(buffer85, 'uint16', 174, 29);
} catch {}
let arrayBuffer9 = buffer10.getMappedRange(24, 0);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 8, depthOrArrayLayers: 13}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture158,
  mipLevel: 0,
  origin: {x: 5, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture206 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture207 = device0.createTexture({
  size: [12, 12, 17],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView187 = texture172.createView({arrayLayerCount: 1});
let computePassEncoder23 = commandEncoder87.beginComputePass();
try {
computePassEncoder23.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder23.drawIndexed(0, 0, 0, 54_451_500);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer4, 96);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(7, buffer94, 0, 6);
} catch {}
try {
renderBundleEncoder37.setIndexBuffer(buffer92, 'uint16', 0, 2);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(37); };
} catch {}
try {
computePassEncoder9.setBindGroup(2, bindGroup59);
} catch {}
try {
renderPassEncoder19.drawIndexed(0, 672, 0, 1_174_588_624, 1_070_595_160);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 4, height: 4, depthOrArrayLayers: 4}
*/
{
  source: img3,
  origin: { x: 4, y: 49 },
  flipY: true,
}, {
  texture: texture182,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData23 = new ImageData(12, 12);
let buffer128 = device0.createBuffer({
  label: '\u2631\u4550\u{1fdb5}\u{1fe74}\u88b5\u94c7\ude79\uf94b',
  size: 28,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let commandEncoder157 = device0.createCommandEncoder({});
let texture208 = gpuCanvasContext2.getCurrentTexture();
let textureView188 = texture49.createView({});
let renderBundleEncoder39 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder3.setBindGroup(2, bindGroup59);
} catch {}
try {
renderPassEncoder19.drawIndexed(0, 86, 0, 39_005_413, 820_741_047);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer40, 8);
} catch {}
let buffer129 = device0.createBuffer({
  size: 68,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder158 = device0.createCommandEncoder({});
let texture209 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 78},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder40 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder23.drawIndexedIndirect(buffer129, 0);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup8, new Uint32Array(1362), 258, 0);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer129, 'uint32', 8, 25);
} catch {}
try {
commandEncoder85.resolveQuerySet(querySet1, 86, 3, buffer32, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline40 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}});
let autogeneratedBindGroupLayout17 = pipeline24.getBindGroupLayout(0);
let buffer130 = device0.createBuffer({size: 272, usage: GPUBufferUsage.UNIFORM});
let commandEncoder159 = device0.createCommandEncoder({});
try {
renderPassEncoder23.drawIndexed(0, 0, 0, 15_864_453, 0);
} catch {}
let pipeline41 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}});
let pipeline42 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x3603f0d4},
  fragment: {module: shaderModule4, constants: {}, targets: [{format: 'rg8uint', writeMask: 0}]},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 72,
        attributes: [
          {format: 'uint32x3', offset: 0, shaderLocation: 15},
          {format: 'uint32x3', offset: 4, shaderLocation: 5},
          {format: 'float16x4', offset: 20, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 1},
          {format: 'snorm16x2', offset: 24, shaderLocation: 6},
          {format: 'float32x2', offset: 8, shaderLocation: 2},
          {format: 'sint8x2', offset: 2, shaderLocation: 13},
          {format: 'unorm16x4', offset: 0, shaderLocation: 10},
          {format: 'float16x2', offset: 0, shaderLocation: 0},
          {format: 'snorm8x4', offset: 0, shaderLocation: 9},
          {format: 'float16x2', offset: 16, shaderLocation: 3},
          {format: 'sint16x4', offset: 12, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 88,
        attributes: [
          {format: 'sint16x4', offset: 20, shaderLocation: 12},
          {format: 'float16x4', offset: 0, shaderLocation: 8},
          {format: 'uint32x2', offset: 16, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'back', unclippedDepth: true},
});
let pipelineLayout5 = device0.createPipelineLayout({
  bindGroupLayouts: [autogeneratedBindGroupLayout8, recycledExplicitBindGroupLayout2, veryExplicitBindGroupLayout19, autogeneratedBindGroupLayout1],
});
let commandEncoder160 = device0.createCommandEncoder({});
let renderPassEncoder36 = commandEncoder127.beginRenderPass({
  colorAttachments: [{
  view: textureView185,
  depthSlice: 5,
  clearValue: { r: 959.2, g: 159.8, b: -857.3, a: 17.63, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
});
let sampler29 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat'});
try {
computePassEncoder7.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup19, new Uint32Array(336), 49, 0);
} catch {}
try {
renderPassEncoder23.drawIndexed(0, 0, 0, 5_361_368);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer39, 'uint16', 98, 102);
} catch {}
try {
renderBundleEncoder40.setIndexBuffer(buffer24, 'uint16', 2, 6);
} catch {}
let commandEncoder161 = device0.createCommandEncoder();
let textureView189 = texture129.createView({dimension: '2d-array'});
try {
computePassEncoder1.setBindGroup(1, bindGroup69, new Uint32Array(4304), 112, 0);
} catch {}
try {
renderPassEncoder23.drawIndexedIndirect(buffer119, 36);
} catch {}
try {
renderBundleEncoder40.setPipeline(pipeline17);
} catch {}
try {
buffer13.unmap();
} catch {}
let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'bt2020_10bit'} });
let buffer131 = device0.createBuffer({size: 608, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder6.setBindGroup(3, bindGroup34, new Uint32Array(1107), 66, 0);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline11);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline43 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule4, entryPoint: 'fragment5', targets: [{format: 'rg8uint'}]},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex3',
    buffers: [
      {
        arrayStride: 72,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 2, shaderLocation: 0},
          {format: 'sint16x2', offset: 32, shaderLocation: 12},
          {format: 'unorm8x4', offset: 4, shaderLocation: 2},
          {format: 'float32x3', offset: 0, shaderLocation: 6},
          {format: 'sint8x4', offset: 4, shaderLocation: 14},
          {format: 'unorm8x4', offset: 8, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 12,
        attributes: [
          {format: 'sint32x2', offset: 0, shaderLocation: 13},
          {format: 'float16x4', offset: 0, shaderLocation: 8},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10},
          {format: 'uint16x2', offset: 0, shaderLocation: 15},
          {format: 'uint32', offset: 0, shaderLocation: 5},
          {format: 'unorm16x2', offset: 0, shaderLocation: 4},
          {format: 'float16x2', offset: 0, shaderLocation: 9},
        ],
      },
      {arrayStride: 128, attributes: [{format: 'uint8x2', offset: 0, shaderLocation: 11}]},
    ],
  },
});
document.body.append(canvas5);
let autogeneratedBindGroupLayout18 = pipeline43.getBindGroupLayout(0);
let textureView190 = texture178.createView({mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 2});
try {
computePassEncoder1.setBindGroup(2, bindGroup32);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 81_421_162);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup23);
} catch {}
try {
renderBundleEncoder36.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(2, buffer55, 0);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let buffer132 = device0.createBuffer({size: 32, usage: GPUBufferUsage.VERTEX});
try {
renderPassEncoder8.draw(346, 0, 330_946_482);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer115, 16);
} catch {}
let imageData24 = new ImageData(16, 20);
let texture210 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 45},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder41 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
try {
renderPassEncoder16.setBindGroup(3, bindGroup2, new Uint32Array(140), 19, 0);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 170_947_740);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer95, 'uint16', 26, 2);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC});
} catch {}
let buffer133 = device0.createBuffer({size: 4, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder162 = device0.createCommandEncoder();
let textureView191 = texture36.createView({dimension: '2d-array', aspect: 'all'});
let renderPassEncoder37 = commandEncoder149.beginRenderPass({colorAttachments: [{view: textureView82, depthSlice: 139, loadOp: 'clear', storeOp: 'store'}]});
try {
renderPassEncoder8.draw(36, 0, 249_444_461);
} catch {}
try {
renderPassEncoder23.drawIndexed(0, 0, 0, 482_513_012, 0);
} catch {}
let commandEncoder163 = device0.createCommandEncoder({});
try {
computePassEncoder14.setBindGroup(0, bindGroup36);
} catch {}
try {
renderPassEncoder8.draw(31, 0, 1_141_217_653, 0);
} catch {}
try {
renderPassEncoder23.drawIndexed(0, 0, 0, 63_184_261);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer95, 0);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
try {
  await promise24;
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, -1_848_874_021);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer62, 24);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer112, 8);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(0, buffer88, 44);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer91, 'uint16', 244, 246);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline14);
} catch {}
try {
commandEncoder100.copyTextureToTexture({
  texture: texture111,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture111,
  mipLevel: 0,
  origin: {x: 1, y: 11, z: 0},
  aspect: 'all',
},
{width: 12, height: 11, depthOrArrayLayers: 0});
} catch {}
let bindGroup77 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout14,
  entries: [{binding: 0, resource: {buffer: buffer112, size: 84}}],
});
let texture211 = device0.createTexture({
  size: [655, 1, 7],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder24.setBindGroup(1, bindGroup13, new Uint32Array(1223), 110, 0);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer14, 'uint16', 10, 0);
} catch {}
try {
commandEncoder123.resolveQuerySet(querySet2, 50, 0, buffer121, 0);
} catch {}
let commandEncoder164 = device0.createCommandEncoder({});
let texture212 = device0.createTexture({
  size: [48, 48, 58],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView192 = texture140.createView({baseMipLevel: 0, baseArrayLayer: 0});
try {
renderPassEncoder33.setStencilReference(1673);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup11);
} catch {}
let promise25 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute1'}});
let texture213 = device0.createTexture({
  size: [48, 48, 150],
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture214 = device0.createTexture({
  size: {width: 655, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  dimension: '2d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder25.setBindGroup(3, bindGroup41, [0]);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup47, new Uint32Array(1831), 88, 0);
} catch {}
try {
renderPassEncoder26.beginOcclusionQuery(236);
} catch {}
try {
renderPassEncoder19.draw(45, 140, 727_675_734, 2_436_327_752);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder165 = device0.createCommandEncoder();
let textureView193 = texture120.createView({dimension: 'cube-array', aspect: 'all', format: 'rg32uint', baseArrayLayer: 2, arrayLayerCount: 6});
try {
renderPassEncoder19.draw(95, 4, 1_467_916_335, 994_801_433);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 275_245);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer60, 'uint16', 218, 61);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
document.body.append(img2);
let bindGroup78 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 0, resource: textureView57},
    {binding: 2, resource: textureView6},
    {binding: 20, resource: {buffer: buffer77}},
    {binding: 9, resource: externalTexture5},
  ],
});
let textureView194 = texture213.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder19.drawIndexed(0, 190, 0, -1_751_780_766, 389_353_701);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer15, 0);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer93, 'uint16', 0, 5);
} catch {}
try {
device0.queue.writeBuffer(buffer96, 20, new DataView(new ArrayBuffer(81216)), 1242, 24);
} catch {}
let videoFrame34 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470bg', transfer: 'linear'} });
let texture215 = device0.createTexture({
  size: [24, 24, 75],
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture216 = device0.createTexture({
  size: [24, 24, 1],
  mipLevelCount: 3,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder23.end();
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 200_570_384);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline12);
} catch {}
try {
buffer11.unmap();
} catch {}
let textureView195 = texture215.createView({dimension: '3d'});
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 225_042_419);
} catch {}
try {
renderBundleEncoder29.setBindGroup(3, bindGroup15, new Uint32Array(1463), 200, 0);
} catch {}
try {
renderBundleEncoder39.setIndexBuffer(buffer95, 'uint32', 8, 20);
} catch {}
try {
device0.queue.writeBuffer(buffer87, 4, new Float32Array(9362).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7962)), 133, 24);
} catch {}
let commandBuffer12 = commandEncoder57.finish();
let texture217 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 655},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView196 = texture106.createView({});
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.draw(187, 0, 1_202_658_656);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer62, 28);
} catch {}
try {
commandEncoder164.copyTextureToBuffer({
  texture: texture210,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 8276 */
  offset: 2900,
  bytesPerRow: 5376,
  buffer: buffer56,
}, {width: 0, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeBuffer(buffer60, 60, new Float64Array(3643).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/3640)), 24, 0);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
await gc();
let pipelineLayout6 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout1, autogeneratedBindGroupLayout4, veryExplicitBindGroupLayout17, autogeneratedBindGroupLayout1],
});
let textureView197 = texture211.createView({mipLevelCount: 1});
let sampler30 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 4,
});
try {
renderPassEncoder8.drawIndexedIndirect(buffer120, 4);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer111, 'uint32', 36, 23);
} catch {}
try {
  await shaderModule2.getCompilationInfo();
} catch {}
try {
device0.queue.submit([commandBuffer12]);
} catch {}
let texture218 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView198 = texture81.createView({});
try {
renderPassEncoder19.drawIndexed(0, 15, 0, 162_902_086, 380_949_483);
} catch {}
try {
renderBundleEncoder33.setPipeline(pipeline11);
} catch {}
try {
buffer10.unmap();
} catch {}
let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({
  label: '\ue5b7\u{1fac6}\u0c47\uc603\u{1fc39}\u1870\u0942\uac1d\ud790',
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' },
    },
    {binding: 4, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {binding: 56, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 73,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {binding: 88, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 164,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder166 = device0.createCommandEncoder({});
let texture219 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 11},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView199 = texture140.createView({});
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 490_299_948);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer61, 32);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer112, 32);
} catch {}
let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'pq'} });
let buffer134 = device0.createBuffer({size: 272, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture220 = device0.createTexture({
  size: {width: 12, height: 12, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView200 = texture74.createView({mipLevelCount: 1});
try {
computePassEncoder22.setBindGroup(2, bindGroup7);
} catch {}
try {
renderBundleEncoder23.setBindGroup(2, bindGroup17, new Uint32Array(3428), 664, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 327, height: 1, depthOrArrayLayers: 21}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture153,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData25 = new ImageData(48, 68);
let commandEncoder167 = device0.createCommandEncoder({});
let textureView201 = texture128.createView({dimension: '2d-array'});
let renderPassEncoder38 = commandEncoder121.beginRenderPass({
  colorAttachments: [{
  view: textureView199,
  depthSlice: 13,
  clearValue: { r: 221.4, g: 166.6, b: -827.3, a: -398.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder8.draw(91, 0, 559_883_472);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer119, 20);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer83, 88);
} catch {}
try {
computePassEncoder20.insertDebugMarker('\u94b3');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let canvas6 = document.createElement('canvas');
let commandEncoder168 = device0.createCommandEncoder({});
try {
renderPassEncoder31.setBindGroup(0, bindGroup70);
} catch {}
try {
renderPassEncoder19.draw(9, 21, 646_797_547, 21_792_232);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 172_239_389);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer111, 68);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(0, buffer124);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup37, new Uint32Array(1498), 212, 0);
} catch {}
try {
renderBundleEncoder12.drawIndirect(buffer50, 12);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer1, 'uint32', 132, 88);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline35);
} catch {}
let autogeneratedBindGroupLayout19 = pipeline13.getBindGroupLayout(0);
let bindGroup79 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 286, resource: {buffer: buffer88}},
    {binding: 1, resource: textureView91},
    {binding: 332, resource: {buffer: buffer126, size: 504}},
    {binding: 4, resource: {buffer: buffer7, size: 256}},
    {binding: 21, resource: externalTexture0},
    {binding: 76, resource: textureView19},
    {binding: 16, resource: {buffer: buffer124, size: 84}},
  ],
});
try {
computePassEncoder12.setBindGroup(3, bindGroup53);
} catch {}
try {
renderPassEncoder8.draw(537, 0, 1_688_034_838);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 686_153_187);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline27);
} catch {}
try {
commandEncoder90.copyBufferToBuffer(buffer114, 132, buffer103, 4, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer44, 0, new DataView(new Uint8Array(39934).map((_, i) => i).buffer), 12940, 16);
} catch {}
let bindGroup80 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 9, resource: externalTexture19},
    {binding: 2, resource: textureView169},
    {binding: 20, resource: {buffer: buffer121}},
    {binding: 0, resource: textureView156},
  ],
});
let commandEncoder169 = device0.createCommandEncoder({});
try {
renderPassEncoder8.drawIndexedIndirect(buffer4, 4);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer78, 'uint16', 8, 0);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(1, buffer118, 36, 8);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1310, height: 1, depthOrArrayLayers: 13}
*/
{
  source: imageData17,
  origin: { x: 8, y: 1 },
  flipY: false,
}, {
  texture: texture147,
  mipLevel: 0,
  origin: {x: 52, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture221 = device0.createTexture({
  label: '\uf9de\u8309\ue1a0\u2de4\u0fac\udd3f\u5751\u{1ff45}\u0623\ue1c9',
  size: {width: 327},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView202 = texture65.createView({arrayLayerCount: 2});
try {
computePassEncoder16.setBindGroup(3, bindGroup53);
} catch {}
try {
renderPassEncoder35.setBindGroup(1, bindGroup70);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 445_224_162);
} catch {}
try {
renderBundleEncoder26.setBindGroup(1, bindGroup50);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline35);
} catch {}
try {
commandEncoder68.copyTextureToBuffer({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 20, y: 24, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 880 widthInBlocks: 55 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 592 */
  offset: 592,
  bytesPerRow: 3584,
  buffer: buffer56,
}, {width: 550, height: 16, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
adapter0.label = '\ubb18\u0e0f\u{1f9a8}\u2033\u0c0c\uf67b\u0d14\u5901';
} catch {}
let textureView203 = texture57.createView({});
try {
renderPassEncoder19.drawIndexed(0, 171, 0, 272_371_845, 1_104_208_664);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer121, 84);
} catch {}
try {
buffer42.unmap();
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let pipeline44 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute3'}});
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(13); };
} catch {}
document.body.prepend(canvas3);
let bindGroup81 = device0.createBindGroup({layout: autogeneratedBindGroupLayout15, entries: [{binding: 20, resource: {buffer: buffer49}}]});
let texture222 = device0.createTexture({
  size: [163, 1, 1],
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder14.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup12, new Uint32Array(717), 219, 0);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer52, 36);
} catch {}
try {
renderBundleEncoder34.setBindGroup(0, bindGroup76);
} catch {}
try {
buffer124.unmap();
} catch {}
try {
commandEncoder124.copyTextureToBuffer({
  texture: texture204,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3680 */
  offset: 3680,
  bytesPerRow: 2560,
  buffer: buffer56,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise26;
} catch {}
let buffer135 = device0.createBuffer({size: 276, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder170 = device0.createCommandEncoder();
let textureView204 = texture207.createView({dimension: 'cube'});
try {
computePassEncoder18.setBindGroup(2, bindGroup18);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer129, 20);
} catch {}
try {
renderBundleEncoder40.setBindGroup(2, bindGroup1, new Uint32Array(183), 2, 0);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(1, buffer121, 92, 50);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let gpuCanvasContext7 = canvas6.getContext('webgpu');
let commandEncoder171 = device0.createCommandEncoder({});
try {
renderPassEncoder27.setIndexBuffer(buffer77, 'uint32', 44, 15);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer119, 'uint16', 22, 9);
} catch {}
try {
renderBundleEncoder38.setVertexBuffer(0, buffer75);
} catch {}
document.body.prepend(img3);
let buffer136 = device0.createBuffer({size: 192, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let commandEncoder172 = device0.createCommandEncoder({});
let textureView205 = texture8.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3});
let externalTexture21 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder18.setBindGroup(2, bindGroup45, new Uint32Array(697), 164, 0);
} catch {}
try {
renderPassEncoder16.end();
} catch {}
try {
renderPassEncoder33.setVertexBuffer(6, buffer40, 76, 24);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder173 = device0.createCommandEncoder({});
let texture223 = device0.createTexture({
  size: {width: 163, height: 1, depthOrArrayLayers: 69},
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder19.draw(192, 134, 418_906_562, 260_088_196);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer42, 0);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer48, 0);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(6, buffer124, 0, 5);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeBuffer(buffer37, 0, new BigInt64Array(4176).map((_, i) => BigInt(i - 0)), 160, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 81, height: 1, depthOrArrayLayers: 10}
*/
{
  source: videoFrame21,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture173,
  mipLevel: 1,
  origin: {x: 26, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let texture224 = device0.createTexture({size: [1310, 1, 1], format: 'rg16sint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder5.setBindGroup(3, bindGroup34);
} catch {}
try {
computePassEncoder9.setBindGroup(0, bindGroup43, new Uint32Array(1877), 41, 0);
} catch {}
try {
renderPassEncoder19.end();
} catch {}
try {
renderPassEncoder8.draw(155, 0, 705_398_970, 0);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 575_967_535);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer52, 16);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer83, 48);
} catch {}
try {
commandEncoder147.copyBufferToBuffer(buffer6, 12, buffer98, 12, 0);
} catch {}
try {
commandEncoder60.pushDebugGroup('\ue268');
} catch {}
await gc();
try {
renderPassEncoder8.drawIndexedIndirect(buffer101, 0);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup20, new Uint32Array(1712), 14, 0);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
let textureView206 = texture212.createView({label: '\u14ec\u{1fff4}\u{1fe5a}', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 5});
let texture225 = device0.createTexture({size: [8, 8, 13], format: 'rgba32float', usage: GPUTextureUsage.STORAGE_BINDING});
let textureView207 = texture188.createView({arrayLayerCount: 1});
let externalTexture22 = device0.importExternalTexture({source: videoFrame31, colorSpace: 'srgb'});
try {
computePassEncoder5.setBindGroup(0, bindGroup20, new Uint32Array(1375), 846, 0);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 151_619_444);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer40, 4);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer29, 0, 142);
} catch {}
let commandEncoder174 = device0.createCommandEncoder({});
let textureView208 = texture182.createView({aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder21.setBindGroup(1, bindGroup27);
} catch {}
try {
computePassEncoder2.setBindGroup(3, bindGroup43, new Uint32Array(4305), 1_005, 0);
} catch {}
try {
renderPassEncoder8.draw(484, 0, 394_908_431);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 310_077_082);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer92, 'uint16', 4, 2);
} catch {}
let bindGroup82 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout9,
  entries: [{binding: 1, resource: {buffer: buffer124, size: 132}}],
});
let buffer137 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST});
let commandEncoder175 = device0.createCommandEncoder({});
let textureView209 = texture213.createView({});
try {
renderPassEncoder32.setBindGroup(0, bindGroup77);
} catch {}
try {
renderPassEncoder8.draw(22, 0, 621_866_640);
} catch {}
try {
commandEncoder160.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 80 */
  offset: 80,
  buffer: buffer97,
}, {
  texture: texture115,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let pipeline45 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment5',
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6},
          {format: 'uint16x2', offset: 0, shaderLocation: 15},
          {format: 'snorm8x2', offset: 0, shaderLocation: 2},
          {format: 'float32', offset: 0, shaderLocation: 1},
          {format: 'unorm16x2', offset: 0, shaderLocation: 9},
          {format: 'uint32', offset: 0, shaderLocation: 5},
          {format: 'sint16x2', offset: 0, shaderLocation: 13},
          {format: 'unorm8x2', offset: 0, shaderLocation: 0},
          {format: 'float16x2', offset: 0, shaderLocation: 8},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'unorm8x2', offset: 0, shaderLocation: 4},
          {format: 'sint16x2', offset: 0, shaderLocation: 14},
          {format: 'sint8x4', offset: 0, shaderLocation: 12},
          {format: 'uint8x2', offset: 0, shaderLocation: 11},
        ],
      },
      {arrayStride: 16, stepMode: 'vertex', attributes: [{format: 'snorm8x4', offset: 0, shaderLocation: 3}]},
    ],
  },
});
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(55); };
} catch {}
await gc();
let autogeneratedBindGroupLayout20 = pipeline14.getBindGroupLayout(1);
let commandEncoder176 = device0.createCommandEncoder({});
try {
renderPassEncoder36.setBindGroup(0, bindGroup42, new Uint32Array(3204), 1_055, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer50, 24);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline38);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer51, 'uint16', 8, 10);
} catch {}
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1728 */
  offset: 1728,
  bytesPerRow: 10240,
  buffer: buffer56,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout21 = pipeline37.getBindGroupLayout(0);
let commandEncoder177 = device0.createCommandEncoder();
try {
computePassEncoder18.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder36.setBindGroup(2, bindGroup9, new Uint32Array(74), 13, 0);
} catch {}
try {
renderPassEncoder8.draw(372, 0, 18_384_712);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer4, 24);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder178 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(3, bindGroup1, new Uint32Array(475), 49, 0);
} catch {}
try {
renderPassEncoder8.draw(80, 0, 954_987_091);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer84, 40);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer119, 0);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline26);
} catch {}
try {
device0.queue.writeBuffer(buffer110, 120, new Uint32Array(10652).map((_, i) => i * 9), 4577, 16);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup83 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer77}}]});
let textureView210 = texture32.createView({label: '\u{1f622}\u04c1\u{1f9f6}\u{1f823}'});
let externalTexture23 = device0.importExternalTexture({source: videoFrame28, colorSpace: 'display-p3'});
try {
renderPassEncoder33.setBindGroup(3, bindGroup59, new Uint32Array(3260), 222, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let pipeline46 = await promise25;
let canvas7 = document.createElement('canvas');
let commandEncoder179 = device0.createCommandEncoder({});
try {
renderPassEncoder8.draw(142, 0, 904_011_250);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 152_018_704);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer96, 56);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline1);
} catch {}
let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 108,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let autogeneratedBindGroupLayout22 = pipeline40.getBindGroupLayout(0);
let textureView211 = texture211.createView({dimension: '3d', arrayLayerCount: 1});
try {
computePassEncoder5.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder8.draw(283, 0, 286_448_497, 0);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder30.setBindGroup(1, bindGroup27, new Uint32Array(1205), 453, 0);
} catch {}
try {
renderBundleEncoder33.setVertexBuffer(1, buffer115, 0, 100);
} catch {}
try {
gpuCanvasContext6.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
let videoFrame36 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpteRp431', transfer: 'pq'} });
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 929_514_332);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer115, 20);
} catch {}
try {
renderBundleEncoder39.setIndexBuffer(buffer77, 'uint16', 28, 31);
} catch {}
try {
renderBundleEncoder33.setVertexBuffer(0, buffer121, 44, 15);
} catch {}
try {
device0.queue.writeBuffer(buffer77, 136, new DataView(new Uint8Array(12518).map((_, i) => i).buffer), 1496, 24);
} catch {}
let bindGroup84 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout18,
  entries: [
    {binding: 0, resource: textureView151},
    {binding: 9, resource: externalTexture16},
    {binding: 20, resource: {buffer: buffer121}},
  ],
});
let commandEncoder180 = device0.createCommandEncoder({});
try {
computePassEncoder18.setBindGroup(3, bindGroup34, new Uint32Array(2542), 334, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer76, 68);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(0, buffer87, 8, 8);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup5, new Uint32Array(134), 4, 0);
} catch {}
try {
commandEncoder68.copyTextureToTexture({
  texture: texture180,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture194,
  mipLevel: 0,
  origin: {x: 57, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder37.insertDebugMarker('\ubd10');
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING});
} catch {}
let commandEncoder181 = device0.createCommandEncoder({});
let textureView212 = texture189.createView({baseArrayLayer: 3, arrayLayerCount: 1});
try {
computePassEncoder8.setPipeline(pipeline37);
} catch {}
try {
renderPassEncoder8.draw(295, 0, 1_422_067_070);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 257_459_158);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer42, 0);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(4, buffer118, 16);
} catch {}
let texture226 = device0.createTexture({
  size: {width: 655, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView213 = texture67.createView({dimension: '2d-array'});
let sampler31 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 57.38,
  compare: 'equal',
});
let externalTexture24 = device0.importExternalTexture({source: videoFrame32});
try {
renderPassEncoder25.setBindGroup(2, bindGroup45, new Uint32Array(926), 85, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer42, 4);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup30);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup26, new Uint32Array(4567), 182, 0);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(0, buffer121, 44, 13);
} catch {}
await gc();
let commandEncoder182 = device0.createCommandEncoder({});
try {
computePassEncoder18.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder27.setBindGroup(0, bindGroup81);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup76, new Uint32Array(606), 68, 0);
} catch {}
try {
renderPassEncoder8.draw(83, 0, 697_471_581);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer121, 192);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer108, 16);
} catch {}
try {
renderBundleEncoder37.setIndexBuffer(buffer25, 'uint32', 8, 3);
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup85 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 0, resource: {buffer: buffer38, size: 64}},
    {binding: 1, resource: {buffer: buffer37, size: 152}},
  ],
});
let buffer138 = device0.createBuffer({size: 64, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder183 = device0.createCommandEncoder({});
try {
computePassEncoder19.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(238);
} catch {}
try {
renderPassEncoder8.draw(418, 0, 497_969_388);
} catch {}
try {
renderBundleEncoder40.setVertexBuffer(0, buffer118);
} catch {}
try {
commandEncoder119.copyTextureToTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 172, y: 0, z: 3},
  aspect: 'all',
},
{
  texture: texture184,
  mipLevel: 0,
  origin: {x: 96, y: 0, z: 0},
  aspect: 'all',
},
{width: 110, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline47 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}});
let sampler32 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 89.41,
  maxAnisotropy: 1,
});
try {
computePassEncoder11.setBindGroup(3, bindGroup41, [0]);
} catch {}
try {
renderPassEncoder33.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder8.draw(361, 0, 261_164_944);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer94, 0);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer120, 4);
} catch {}
try {
pipeline5.label = '\u{1f8fa}\u0c59\ud0a7\u40c3\ub5bb\uda6f\u95bf\ud385\u{1f902}\u{1f787}';
} catch {}
let commandEncoder184 = device0.createCommandEncoder({});
let texture227 = device0.createTexture({
  size: {width: 6, height: 6, depthOrArrayLayers: 1},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture25 = device0.importExternalTexture({source: videoFrame26});
try {
renderPassEncoder35.setBindGroup(3, bindGroup61);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
commandEncoder43.copyTextureToBuffer({
  texture: texture149,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 98 */
  offset: 98,
  buffer: buffer96,
}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData26 = new ImageData(4, 68);
let commandEncoder185 = device0.createCommandEncoder({});
try {
renderPassEncoder31.setBindGroup(0, bindGroup34, new Uint32Array(3540), 370, 0);
} catch {}
try {
renderPassEncoder8.draw(354, 0, 179_515_082);
} catch {}
try {
renderPassEncoder8.drawIndexed(1, 0, 0, 330_591_115);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer85, 'uint32', 4, 155);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(6, buffer55, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup45, new Uint32Array(1033), 160, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 68, new Float64Array(12507).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/12505)), 212, 0);
} catch {}
let gpuCanvasContext8 = canvas7.getContext('webgpu');
try {
renderPassEncoder8.drawIndirect(buffer63, 4);
} catch {}
try {
commandEncoder91.resolveQuerySet(querySet1, 53, 3, buffer126, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture180,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(283).fill(42), /* required buffer size: 283 */
{offset: 283, rowsPerImage: 3}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise27;
} catch {}
let commandEncoder186 = device0.createCommandEncoder({});
try {
renderPassEncoder36.setBindGroup(0, bindGroup81, new Uint32Array(494), 116, 0);
} catch {}
try {
renderPassEncoder36.beginOcclusionQuery(382);
} catch {}
try {
renderPassEncoder36.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.draw(46, 0, 242_554_835);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer48, 0);
} catch {}
try {
renderBundleEncoder25.setBindGroup(0, bindGroup66);
} catch {}
try {
globalThis.someLabel = sampler12.label;
} catch {}
let pipeline48 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout6,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x2', offset: 4, shaderLocation: 12},
          {format: 'sint32', offset: 0, shaderLocation: 9},
          {format: 'uint16x4', offset: 0, shaderLocation: 11},
          {format: 'snorm16x4', offset: 0, shaderLocation: 10},
          {format: 'snorm8x2', offset: 2, shaderLocation: 1},
          {format: 'float32x4', offset: 0, shaderLocation: 15},
          {format: 'uint32x3', offset: 0, shaderLocation: 2},
        ],
      },
    ],
  },
});
try {
gpuCanvasContext7.unconfigure();
} catch {}
try {
externalTexture15.label = '\u0212\u{1f603}\u959a\u0469\u00c8\u3171\ufaf9\u1293\u05cf\u089e\u0492';
} catch {}
let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 77,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 134,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let commandBuffer13 = commandEncoder31.finish();
let computePassEncoder24 = commandEncoder56.beginComputePass();
try {
renderPassEncoder38.setBindGroup(1, bindGroup72, new Uint32Array(5330), 337, 0);
} catch {}
try {
renderBundleEncoder40.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(2, buffer102, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer78, 0, new Float32Array(7707).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6511)), 549, 0);
} catch {}
try {
adapter0.label = '\u633e\u0ddd\ub7aa\ud2d4\u5867\u6573';
} catch {}
let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 1, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 288,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let texture228 = device0.createTexture({size: [8], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let textureView214 = texture157.createView({dimension: '1d', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder24.setPipeline(pipeline36);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer101, 0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer1, 'uint16', 44, 8);
} catch {}
try {
commandEncoder113.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 32 */
  offset: 32,
  bytesPerRow: 12288,
  buffer: buffer33,
}, {
  texture: texture83,
  mipLevel: 0,
  origin: {x: 9, y: 1, z: 0},
  aspect: 'all',
}, {width: 10, height: 19, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas2);
let textureView215 = texture227.createView({});
let texture229 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 7},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle2]);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer112, 'uint16', 14, 55);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 12, depthOrArrayLayers: 17}
*/
{
  source: imageData3,
  origin: { x: 34, y: 0 },
  flipY: true,
}, {
  texture: texture207,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout23 = pipeline3.getBindGroupLayout(0);
let commandEncoder187 = device0.createCommandEncoder({});
let texture230 = device0.createTexture({
  size: [1310, 1, 8],
  mipLevelCount: 4,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder10.executeBundles([renderBundle14, renderBundle17, renderBundle14, renderBundle16, renderBundle8]);
} catch {}
try {
commandEncoder142.copyBufferToTexture({
  /* bytesInLastRow: 328 widthInBlocks: 41 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 224 */
  offset: 224,
  bytesPerRow: 1280,
  buffer: buffer111,
}, {
  texture: texture117,
  mipLevel: 0,
  origin: {x: 191, y: 0, z: 0},
  aspect: 'all',
}, {width: 41, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer139 = device0.createBuffer({size: 20, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder188 = device0.createCommandEncoder({});
try {
renderPassEncoder30.setStencilReference(981);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup29, new Uint32Array(5411), 3_303, 0);
} catch {}
try {
device0.queue.submit([commandBuffer13]);
} catch {}
let buffer140 = device0.createBuffer({size: 36, usage: GPUBufferUsage.STORAGE});
let texture231 = device0.createTexture({
  size: [12, 12, 37],
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView216 = texture139.createView({dimension: 'cube', baseMipLevel: 0, baseArrayLayer: 2});
let externalTexture26 = device0.importExternalTexture({source: videoFrame36});
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup23, []);
} catch {}
try {
computePassEncoder12.setBindGroup(1, bindGroup32, new Uint32Array(313), 5, 0);
} catch {}
try {
renderPassEncoder34.setBindGroup(3, bindGroup49, new Uint32Array(640), 130, 0);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup38);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(2, buffer120, 0, 18);
} catch {}
let bindGroup86 = device0.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 20, resource: {buffer: buffer126}}]});
let commandEncoder189 = device0.createCommandEncoder();
let textureView217 = texture98.createView({dimension: '2d-array'});
try {
renderPassEncoder33.beginOcclusionQuery(86);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(3, buffer115, 12, 9);
} catch {}
try {
renderBundleEncoder26.setBindGroup(3, bindGroup81, new Uint32Array(123), 5, 0);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm'],
  toneMapping: {mode: 'extended'},
});
} catch {}
let pipeline49 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {}}});
let commandEncoder190 = device0.createCommandEncoder({});
let texture232 = device0.createTexture({
  size: [327, 1, 85],
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView218 = texture53.createView({});
try {
renderPassEncoder35.setBindGroup(0, bindGroup76);
} catch {}
try {
buffer115.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture129,
  mipLevel: 0,
  origin: {x: 165, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(15).fill(85), /* required buffer size: 15 */
{offset: 15}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 8, depthOrArrayLayers: 13}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture158,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer141 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture233 = device0.createTexture({
  size: {width: 1310},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder30.setPipeline(pipeline6);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
canvas0.height = 650;
let commandEncoder191 = device0.createCommandEncoder({});
let textureView219 = texture206.createView({dimension: '2d-array', aspect: 'all'});
let textureView220 = texture86.createView({});
let sampler33 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 81.33,
});
try {
device0.queue.writeBuffer(buffer44, 44, new DataView(new Uint8Array(5692).map((_, i) => i).buffer), 518, 8);
} catch {}
let commandEncoder192 = device0.createCommandEncoder({});
let textureView221 = texture175.createView({});
try {
computePassEncoder21.end();
} catch {}
try {
computePassEncoder0.setPipeline(pipeline47);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(7, buffer86, 0, 1);
} catch {}
try {
commandEncoder167.copyBufferToBuffer(buffer62, 24, buffer47, 0, 0);
} catch {}
try {
commandEncoder183.copyTextureToTexture({
  texture: texture218,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture12,
  mipLevel: 6,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder68.resolveQuerySet(querySet1, 49, 0, buffer2, 0);
} catch {}
let textureView222 = texture207.createView({
  label: '\u0aa2\u9f03\u08ec\udb29\u278b',
  dimension: 'cube-array',
  baseArrayLayer: 3,
  arrayLayerCount: 6,
});
try {
renderPassEncoder24.drawIndexed(3, 1, 0, 207_731_967);
} catch {}
try {
buffer72.unmap();
} catch {}
let sampler34 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 85.04,
  maxAnisotropy: 1,
});
try {
renderPassEncoder33.endOcclusionQuery();
} catch {}
try {
renderPassEncoder24.draw(65, 1, 341_549_167);
} catch {}
try {
renderPassEncoder24.drawIndexed(2, 1, 0, 392_559_752);
} catch {}
try {
renderPassEncoder24.drawIndirect(buffer101, 16);
} catch {}
try {
renderBundleEncoder30.drawIndirect(buffer121, 8);
} catch {}
try {
renderBundleEncoder40.setPipeline(pipeline6);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder60.popDebugGroup();
} catch {}
await gc();
let buffer142 = device0.createBuffer({size: 14272, usage: GPUBufferUsage.INDIRECT});
let commandEncoder193 = device0.createCommandEncoder();
let texture234 = device0.createTexture({
  size: {width: 655, height: 1, depthOrArrayLayers: 16},
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder14.setBindGroup(3, bindGroup46, new Uint32Array(2051), 8, 2);
} catch {}
try {
renderPassEncoder24.draw(138, 1, 983_049_687);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer95, 'uint16', 0, 17);
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(3, buffer35, 0, 9);
} catch {}
try {
device0.queue.writeBuffer(buffer133, 0, new DataView(new ArrayBuffer(5657)), 1677, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 163, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData25,
  origin: { x: 12, y: 10 },
  flipY: true,
}, {
  texture: texture164,
  mipLevel: 0,
  origin: {x: 78, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder194 = device0.createCommandEncoder();
try {
renderPassEncoder24.draw(206, 1, 215_826_418);
} catch {}
try {
renderPassEncoder24.drawIndexedIndirect(buffer119, 8);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer47, 'uint16', 2, 10);
} catch {}
try {
renderBundleEncoder30.drawIndexed(3, 92, 1, 8_354_516, 237_917_801);
} catch {}
let commandEncoder195 = device0.createCommandEncoder({});
try {
renderPassEncoder29.setBindGroup(0, bindGroup72);
} catch {}
try {
renderPassEncoder24.drawIndexed(2, 1, 0, 341_398_296);
} catch {}
try {
renderPassEncoder24.drawIndirect(buffer82, 0);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer15, 'uint16', 4, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 6, height: 6, depthOrArrayLayers: 18}
*/
{
  source: videoFrame23,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture235 = device0.createTexture({
  size: [327, 1, 39],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder28.setBindGroup(3, bindGroup62);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(1, buffer57, 0, 1);
} catch {}
try {
buffer63.unmap();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer143 = device0.createBuffer({size: 124, usage: GPUBufferUsage.VERTEX});
let texture236 = device0.createTexture({
  size: {width: 12},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder36.setBindGroup(1, bindGroup26, new Uint32Array(2524), 19, 0);
} catch {}
try {
renderPassEncoder24.drawIndexedIndirect(buffer94, 28);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer43, 'uint16', 0, 11);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer83, 'uint16', 44, 44);
} catch {}
try {
renderBundleEncoder33.setPipeline(pipeline21);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(2, buffer35);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Uint16Array(7892).map((_, i) => i + 2), 775, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture207,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(81_812).fill(47), /* required buffer size: 81_812 */
{offset: 131, bytesPerRow: 147, rowsPerImage: 185}, {width: 6, height: 1, depthOrArrayLayers: 4});
} catch {}
await gc();
let textureView223 = texture185.createView({format: 'rg16sint'});
let renderPassEncoder39 = commandEncoder81.beginRenderPass({
  colorAttachments: [{
  view: textureView40,
  clearValue: { r: -786.7, g: 502.7, b: 902.4, a: 404.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet2,
});
try {
renderPassEncoder24.drawIndexed(2, 1, 0, 279_616_601);
} catch {}
try {
renderPassEncoder24.drawIndexedIndirect(buffer101, 8);
} catch {}
try {
renderBundleEncoder39.setBindGroup(0, bindGroup8, new Uint32Array(90), 9, 0);
} catch {}
try {
renderBundleEncoder30.drawIndirect(buffer111, 108);
} catch {}
try {
commandEncoder118.copyTextureToTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
},
{
  texture: texture100,
  mipLevel: 0,
  origin: {x: 198, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder48.resolveQuerySet(querySet2, 29, 1, buffer12, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline50 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule2, targets: [{format: 'rg8uint'}]},
  vertex: {module: shaderModule3, entryPoint: 'vertex2', buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16'},
});
await gc();
let autogeneratedBindGroupLayout24 = pipeline15.getBindGroupLayout(0);
let commandBuffer14 = commandEncoder21.finish();
let sampler35 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', compare: 'not-equal'});
try {
renderPassEncoder24.drawIndexedIndirect(buffer42, 4);
} catch {}
try {
renderBundleEncoder30.drawIndirect(buffer123, 12);
} catch {}
let pipeline51 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
let bindGroup87 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 161, resource: externalTexture22}, {binding: 2, resource: textureView12}],
});
let buffer144 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandBuffer15 = commandEncoder34.finish();
let texture237 = device0.createTexture({
  size: {width: 655},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder36.setBindGroup(2, bindGroup34);
} catch {}
try {
renderPassEncoder35.setBindGroup(1, bindGroup59, new Uint32Array(60), 5, 0);
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle2, renderBundle8]);
} catch {}
try {
renderBundleEncoder40.drawIndexedIndirect(buffer129, 0);
} catch {}
try {
renderBundleEncoder40.drawIndirect(buffer15, 0);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline39);
} catch {}
try {
commandEncoder97.resolveQuerySet(querySet1, 8, 42, buffer64, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer133, 0, new DataView(new ArrayBuffer(1912)), 62, 0);
} catch {}
let renderBundle20 = renderBundleEncoder40.finish({});
try {
computePassEncoder24.setBindGroup(1, bindGroup45, new Uint32Array(105), 7, 0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle17, renderBundle2]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer96, 'uint32', 12, 47);
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer51);
} catch {}
try {
renderBundleEncoder30.draw(9, 50, 816_889_963, 420_640_698);
} catch {}
try {
renderBundleEncoder30.drawIndexed(8, 75, 2, 301_658_019, 642_151_876);
} catch {}
await gc();
let bindGroup88 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 0, resource: {buffer: buffer34}},
    {binding: 194, resource: externalTexture7},
    {binding: 16, resource: externalTexture22},
    {binding: 2, resource: textureView105},
    {binding: 108, resource: sampler18},
  ],
});
try {
renderPassEncoder29.draw(152, 92, 612_239_703, 1_188_557_337);
} catch {}
try {
renderPassEncoder29.drawIndexedIndirect(buffer61, 16);
} catch {}
try {
renderPassEncoder29.drawIndirect(buffer115, 4);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer24, 'uint16', 0, 1);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(0, buffer88, 16, 101);
} catch {}
try {
renderBundleEncoder30.drawIndexed(5, 362, 0, -1_621_291_139, 594_907_506);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder171.resolveQuerySet(querySet2, 4, 0, buffer2, 0);
} catch {}
let autogeneratedBindGroupLayout25 = pipeline51.getBindGroupLayout(0);
let commandEncoder196 = device0.createCommandEncoder({});
try {
renderPassEncoder10.setBindGroup(0, bindGroup12, new Uint32Array(2300), 589, 0);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer55, 'uint16', 2, 51);
} catch {}
let buffer145 = device0.createBuffer({size: 328, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder28.setBindGroup(0, bindGroup44);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(2, buffer57, 0, 5);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup13, new Uint32Array(747), 365, 0);
} catch {}
try {
renderBundleEncoder28.draw(0, 415, 0, 39_311_742);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer77, 'uint32', 172, 75);
} catch {}
try {
device0.queue.submit([commandBuffer14]);
} catch {}
let buffer146 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let textureView224 = texture209.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder16.setBindGroup(2, bindGroup67);
} catch {}
try {
renderPassEncoder29.drawIndirect(buffer120, 40);
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup77, new Uint32Array(4316), 2_104, 0);
} catch {}
try {
renderBundleEncoder37.setIndexBuffer(buffer83, 'uint32', 16, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 40, height: 1, depthOrArrayLayers: 10}
*/
{
  source: imageBitmap2,
  origin: { x: 44, y: 14 },
  flipY: false,
}, {
  texture: texture173,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup89 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 0, resource: {buffer: buffer81, offset: 0}}],
});
let commandEncoder197 = device0.createCommandEncoder({});
let texture238 = device0.createTexture({
  size: [163, 1, 1],
  mipLevelCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder33.setBindGroup(3, bindGroup76);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup13, new Uint32Array(1005), 280, 0);
} catch {}
try {
renderPassEncoder29.draw(55, 87, 1_071_521_909, 625_086_351);
} catch {}
try {
renderPassEncoder29.drawIndexedIndirect(buffer138, 4);
} catch {}
try {
renderBundleEncoder30.drawIndexedIndirect(buffer4, 16);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(0, buffer143, 0, 29);
} catch {}
try {
commandEncoder123.copyBufferToBuffer(buffer60, 40, buffer96, 8, 132);
} catch {}
try {
renderPassEncoder24.end();
} catch {}
try {
renderPassEncoder29.drawIndexedIndirect(buffer112, 4);
} catch {}
try {
commandEncoder177.insertDebugMarker('\u2086');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([commandBuffer15]);
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
let textureView225 = texture231.createView({dimension: '3d', aspect: 'all', baseArrayLayer: 0});
let renderBundle21 = renderBundleEncoder30.finish({});
try {
computePassEncoder15.setBindGroup(2, bindGroup68, []);
} catch {}
try {
renderPassEncoder29.draw(61, 114, 931_891_651, 879_476_844);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline38);
} catch {}
try {
commandEncoder50.insertDebugMarker('\u331b');
} catch {}
let pipeline52 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4, constants: {}}});
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(28); };
} catch {}
try {
renderPassEncoder29.drawIndexedIndirect(buffer123, 16);
} catch {}
try {
renderBundleEncoder29.setBindGroup(2, bindGroup43);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer102, 'uint16', 36, 32);
} catch {}
let commandEncoder198 = device0.createCommandEncoder({});
let texture239 = device0.createTexture({
  size: [8, 8, 13],
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder29.end();
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer47, 'uint16', 12, 1);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
renderBundleEncoder19.setBindGroup(2, bindGroup28);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer85, 'uint32', 84, 83);
} catch {}
let imageData27 = new ImageData(40, 8);
try {
computePassEncoder23.setBindGroup(0, bindGroup19, []);
} catch {}
try {
renderPassEncoder28.setBindGroup(2, bindGroup72);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup52, new Uint32Array(4634), 744, 0);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer74, 'uint16', 8, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let bindGroup90 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer102}}]});
try {
computePassEncoder23.setBindGroup(1, bindGroup75);
} catch {}
try {
renderBundleEncoder28.draw(0, 82, 0, 962_309_286);
} catch {}
try {
renderBundleEncoder29.drawIndexed(3, 1, 0, 1_183_358_782, 2);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline3);
} catch {}
try {
  await promise28;
} catch {}
await gc();
let bindGroup91 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 2, resource: textureView17}, {binding: 161, resource: externalTexture20}],
});
let commandBuffer16 = commandEncoder36.finish();
let texture240 = device0.createTexture({
  size: {width: 48, height: 48, depthOrArrayLayers: 150},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView226 = texture105.createView({label: '\u31db\u06df\u1368', baseMipLevel: 0});
try {
renderBundleEncoder33.setBindGroup(0, bindGroup13);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 163, height: 1, depthOrArrayLayers: 78}
*/
{
  source: canvas2,
  origin: { x: 32, y: 15 },
  flipY: true,
}, {
  texture: texture209,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 18},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder199 = device0.createCommandEncoder({});
let textureView227 = texture133.createView({});
try {
renderPassEncoder10.setIndexBuffer(buffer77, 'uint32', 32, 42);
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer123, 20);
} catch {}
try {
commandEncoder45.copyTextureToBuffer({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 215, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 302 widthInBlocks: 151 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 182 */
  offset: 182,
  bytesPerRow: 5120,
  buffer: buffer40,
}, {width: 151, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline53 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 204, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 104, shaderLocation: 15},
          {format: 'float32x3', offset: 308, shaderLocation: 1},
          {format: 'uint32x3', offset: 556, shaderLocation: 2},
          {format: 'float16x2', offset: 68, shaderLocation: 12},
          {format: 'unorm16x4', offset: 376, shaderLocation: 10},
        ],
      },
      {arrayStride: 64, attributes: [{format: 'sint8x2', offset: 2, shaderLocation: 9}]},
    ],
  },
});
let buffer147 = device0.createBuffer({size: 136, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let texture241 = gpuCanvasContext1.getCurrentTexture();
let sampler36 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 92.17});
try {
computePassEncoder16.setBindGroup(0, bindGroup7, new Uint32Array(87), 15, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer77, 'uint32', 76, 27);
} catch {}
try {
renderBundleEncoder28.draw(0, 64, 0, 107_066_504);
} catch {}
await gc();
let buffer148 = device0.createBuffer({size: 20, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder200 = device0.createCommandEncoder();
let textureView228 = texture209.createView({mipLevelCount: 1});
let externalTexture27 = device0.importExternalTexture({source: videoFrame25});
try {
renderBundleEncoder29.draw(16, 2, 961_192_709);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer55, 'uint32', 0, 36);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline3);
} catch {}
try {
  await buffer114.mapAsync(GPUMapMode.WRITE);
} catch {}
try {
commandEncoder159.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture184,
  mipLevel: 0,
  origin: {x: 347, y: 0, z: 0},
  aspect: 'all',
},
{width: 64, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder35.insertDebugMarker('\ub136');
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
renderPassEncoder27.setBindGroup(3, bindGroup48, new Uint32Array(1056), 66, 0);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline53);
} catch {}
try {
renderBundleEncoder39.setBindGroup(2, bindGroup61);
} catch {}
try {
renderBundleEncoder29.drawIndexed(5, 1, 0, 167_015_427);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer4, 4);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer1, 'uint16', 56, 75);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline43);
} catch {}
try {
  await shaderModule6.getCompilationInfo();
} catch {}
try {
commandEncoder179.resolveQuerySet(querySet0, 4, 1, buffer94, 0);
} catch {}
let commandEncoder201 = device0.createCommandEncoder({});
try {
renderPassEncoder10.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder29.drawIndexed(3, 1, 1, -1_926_780_995, 1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 8, depthOrArrayLayers: 8}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture182,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas4);
await gc();
let buffer149 = device0.createBuffer({
  size: 48,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture242 = device0.createTexture({
  label: '\u4b88\u6f90\ub893\u05ff\u849b',
  size: [48, 48, 8],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder19.setPipeline(pipeline32);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer108, 12);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline17);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup92 = device0.createBindGroup({layout: autogeneratedBindGroupLayout25, entries: [{binding: 0, resource: {buffer: buffer118}}]});
let commandEncoder202 = device0.createCommandEncoder({});
try {
computePassEncoder8.insertDebugMarker('\u1e19');
} catch {}
document.body.prepend(img4);
let autogeneratedBindGroupLayout26 = pipeline19.getBindGroupLayout(0);
let bindGroup93 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout22,
  entries: [{binding: 144, resource: {buffer: buffer38}}, {binding: 2, resource: textureView32}],
});
let texture243 = device0.createTexture({
  size: {width: 1310, height: 1, depthOrArrayLayers: 57},
  mipLevelCount: 2,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder29.draw(145, 1, 519_980_205, 2);
} catch {}
try {
renderBundleEncoder29.drawIndexed(4, 1, 0, 470_169_973);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer123, 20);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer142, 1_972);
} catch {}
try {
renderBundleEncoder33.setVertexBuffer(7, buffer2);
} catch {}
let commandEncoder203 = device0.createCommandEncoder();
let commandBuffer17 = commandEncoder65.finish();
let texture244 = device0.createTexture({
  size: {width: 327, height: 1, depthOrArrayLayers: 477},
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder9.setBindGroup(2, bindGroup83, new Uint32Array(622), 371, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer119, 4, 53);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline27);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture140,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(184).fill(74), /* required buffer size: 184 */
{offset: 184, bytesPerRow: 29, rowsPerImage: 16}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 163, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData12,
  origin: { x: 4, y: 12 },
  flipY: false,
}, {
  texture: texture230,
  mipLevel: 3,
  origin: {x: 105, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame5.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame16.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame25.close();
videoFrame26.close();
videoFrame27.close();
videoFrame28.close();
videoFrame29.close();
videoFrame30.close();
videoFrame33.close();
videoFrame35.close();
videoFrame36.close();
}

onload = async () => {
  try {
  let sharedScript = document.querySelector('#shared').textContent;

  let workers = [

  ];
  let promises = [ window0(), window1() ];
  log('promises created');
  let results = await Promise.allSettled(promises);
  for (let result of results) {
    if (result.status === 'rejected') { throw result.reason; }
  }
  log('the end')
  log(location);
  } catch (e) {
    log('error');
    log(e);
    log(e[Symbol.toStringTag]);
    log(e.stack);
    if (e instanceof GPUPipelineError) {
      log(`${e} - ${e.reason}`);
      
    } else if (e instanceof DOMException) {
      if (e.name === 'OperationError') {
      log(e.message);
      
      } else if (e.name === 'InvalidStateError') {
      } else {
        log(e);
        
      }
    } else if (e instanceof GPUValidationError) {
      
    } else if (e instanceof GPUOutOfMemoryError) {
      
    } else if (e instanceof TypeError) {
      log(e);
      
    } else {
      log('unexpected error type');
      log(e);
      
    }
  }
  debug('Pass');
  globalThis.testRunner?.dumpAsText();
  globalThis.testRunner?.notifyDone();
};
</script>