LayoutTests/fast/webgpu/nocrash/fuzz-290344.html

<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',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
  ],
  requiredLimits: {
    minStorageBufferOffsetAlignment: 256,
    maxUniformBufferBindingSize: 28022643,
    maxStorageBufferBindingSize: 142274467,
    maxUniformBuffersPerShaderStage: 12,
  },
});
let buffer0 = device0.createBuffer({size: 10, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture0 = device0.createTexture({
  size: [816, 1, 434],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder0 = device0.createCommandEncoder({});
let textureView0 = texture0.createView({mipLevelCount: 1});
let texture1 = device0.createTexture({
  size: [102, 1, 68],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['r16uint']});
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint16', 0, 4);
} catch {}
try {
buffer0.unmap();
} catch {}
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 11,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 407,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 44, hasDynamicOffset: true },
    },
  ],
});
let textureView1 = texture0.createView({});
let texture2 = device0.createTexture({
  size: {width: 372, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 9,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
    {binding: 1, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 90,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout1]});
let texture3 = device0.createTexture({
  size: [204, 1, 31],
  sampleCount: 1,
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let buffer1 = device0.createBuffer({size: 100, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture4 = device0.createTexture({
  size: [90, 52, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1]});
let texture5 = device0.createTexture({
  size: {width: 2345, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView2 = texture1.createView({format: 'r8sint', mipLevelCount: 1});
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout0]});
let buffer2 = device0.createBuffer({size: 20364, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder1 = device0.createCommandEncoder({});
let texture6 = device0.createTexture({
  size: [372, 1, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView3 = texture3.createView({aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 1});
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'smpteSt4281'} });
let shaderModule0 = device0.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

enable f16;

diagnostic(info, xyz);

@group(1) @binding(2) var<storage, read_write> buffer5: array<array<array<array<f16, 3>, 1>, 2>>;

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

var<workgroup> vw0: T10;

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

struct T3 {
  f0: T2,
}

struct VertexInput5 {
  @location(2) @interpolate(flat, sample) location_2: f32,
}

struct T5 {
  f0: T1,
}

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

struct T7 {
  f0: T5,
}

struct VertexInput3 {
  @location(0) @interpolate(linear, either) location_0: vec4h,
  @builtin(instance_index) instance_index: u32,
  @location(5) location_5: f32,
  @builtin(vertex_index) vertex_index: u32,
  @location(12) location_12: u32,
  @location(13) location_13: vec2i,
  @location(4) @interpolate(flat, first) location_4: vec2u,
  @location(10) @interpolate(flat, sample) location_10: vec2u,
  @location(7) @interpolate(perspective, first) location_7: f32,
  @location(11) @interpolate(flat) location_11: vec2f,
}

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

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

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

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

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

struct VertexInput0 {
  @location(9) location_9: f32,
  @location(6) @interpolate(linear) location_6: vec4h,
}

struct T4 {
  f0: T3,
}

struct VertexInput2 {
  @location(1) @interpolate(flat, either) location_1: vec2i,
}

struct T10 {
  @align(8) @size(56) f0: atomic<u32>,
}

@group(0) @binding(2) var<storage, read_write> buffer3: array<array<array<array<array<f16, 1>, 1>, 6>, 1>>;

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

struct T2 {
  f0: array<array<vec2u, 1>>,
}

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

struct T11 {
  f0: T0,
}

/* zero global variables used */
fn fn0() -> VertexInput1 {
  var out: VertexInput1;
  let ptr0: ptr<function, vec4i> = &out.location_3;
  let vf0: ptr<function, vec4i> = ptr0;
  out.location_3 *= (*vf0);
  return out;
}

struct VertexInput4 {
  @location(8) location_8: vec4f,
}

struct T0 {
  f0: array<u32>,
}

struct VertexOutput0 {
  @location(13) location_13: vec2h,
  @location(12) @interpolate(flat, centroid) location_12: vec4h,
  @location(11) location_11: vec4f,
  @builtin(position) position: vec4f,
  @location(3) @interpolate(linear, center) location_3: vec2h,
}

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

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

struct T9 {
  f0: T0,
}

struct VertexInput6 {
  @location(14) @interpolate(flat, first) location_14: u32,
}

/* used global variables: et1 */
@vertex @must_use
fn vertex0(a0: VertexInput0, a1: VertexInput1, a2: VertexInput2, a3: VertexInput3, a4: VertexInput4, a5: VertexInput5, a6: VertexInput6, @location(15) @interpolate(linear, centroid) location_15: vec4h) -> VertexOutput0 {
  var out: VertexOutput0;
  var vf1: f16 = a0.location_6[unconst_u32(1076312985)];
  var vf2: vec4f = a4.location_8;
  var vf3: vec4i = a1.location_3;
  var vf4: u32 = a6.location_14;
  vf3 = vec4i(textureDimensions(et1).rggg.xzxw);
  return out;
  _ = et1;
}

/* used global variables: buffer3, buffer5 */
@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(global_invocation_id) global_invocation_id: vec3u, a1: ComputeInput0, a2: ComputeInput1) {
  buffer3[unconst_u32(296902801)][unconst_u32(181344114)][unconst_u32(69458874)][unconst_u32(967384277)][unconst_u32(1303880032)] += (*&buffer3)[arrayLength(&(*&buffer3))][0][unconst_u32(328551579)][0][0];
  var vf5: vec2h = faceForward(vec2h(unconst_f16(15664.9), unconst_f16(-1792.8)), vec2h(unconst_f16(4912.2), unconst_f16(-24302.4)), vec2h(unconst_f16(10805.3), unconst_f16(-33389.4)));
  let ptr1: ptr<storage, array<array<array<f16, 1>, 1>, 6>, read_write> = &(*&buffer3)[unconst_u32(1054483628)][0];
  _ = fn0();
  buffer5[unconst_u32(4278495115)][unconst_u32(1134630833)][unconst_u32(566099058)][unconst_u32(438589017)] = (*&buffer3)[arrayLength(&(*&buffer3))][unconst_u32(1123442888)][unconst_u32(274509200)][unconst_u32(207435794)][0];
  var vf6 = fn0();
  atomicCompareExchangeWeak(&vw0.f0, unconst_u32(1191474450), unconst_u32(468684806));
  _ = buffer5;
  _ = buffer3;
}`,
});
let commandEncoder2 = device0.createCommandEncoder({});
let texture7 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'astc-8x6-unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
buffer2.unmap();
} catch {}
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
    {binding: 1, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 90,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let textureView4 = texture5.createView({dimension: '2d-array', mipLevelCount: 1});
let textureView5 = texture1.createView({mipLevelCount: 1});
let commandEncoder3 = device0.createCommandEncoder({label: '\u3b64\u{1f7eb}\u734a\u{1fc34}\u{1fed5}'});
let textureView6 = texture6.createView({aspect: 'all'});
let texture8 = device0.createTexture({
  size: [816, 1, 1],
  sampleCount: 4,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder0.setVertexBuffer(2, buffer2, 0, 9_524);
} catch {}
try {
commandEncoder1.copyBufferToTexture({
  /* bytesInLastRow: 9360 widthInBlocks: 585 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 496 */
  offset: 496,
  bytesPerRow: 21504,
  buffer: buffer2,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 126, y: 1, z: 0},
  aspect: 'all',
}, {width: 585, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder4 = device0.createCommandEncoder({});
let texture9 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'astc-6x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture10 = device0.createTexture({size: [2345, 48, 1], mipLevelCount: 3, format: 'r16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 2, 6);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame1 = new VideoFrame(videoFrame0, {timestamp: 0});
let texture11 = device0.createTexture({
  size: {width: 1172, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'etc2-rgb8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture12 = device0.createTexture({
  size: {width: 180, height: 105, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder1 = commandEncoder1.beginComputePass();
try {
globalThis.someLabel = texture0.label;
} catch {}
let texture13 = device0.createTexture({
  size: [586, 12, 1],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
renderBundleEncoder1.setVertexBuffer(6, buffer1, 12, 3);
} catch {}
try {
commandEncoder4.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3438 */
  offset: 3438,
  bytesPerRow: 16896,
  buffer: buffer2,
}, {
  texture: texture2,
  mipLevel: 5,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture14 = device0.createTexture({
  size: {width: 586, height: 12, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder2 = commandEncoder4.beginComputePass();
try {
renderBundleEncoder1.setIndexBuffer(buffer0, 'uint16', 0, 0);
} catch {}
try {
commandEncoder2.pushDebugGroup('\u{1f98d}');
} catch {}
let pipeline0 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {}}});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let shaderModule1 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

enable f16;

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

/* zero global variables used */
@must_use 
fn fn3(a0: f16) -> array<array<f32, 2>, 1> {
  var out: array<array<f32, 2>, 1>;
  out[unconst_u32(756185970)][unconst_u32(1743574996)] -= log2(vec2f(unconst_f32(0.4554), unconst_f32(0.1485)))[1];
  let ptr6: ptr<function, f32> = &out[0][countTrailingZeros(vec4u((vec4i(unconst_i32(48114644), unconst_i32(296577371), unconst_i32(13244417), unconst_i32(141527344)) <= vec4i(unconst_i32(626221064), unconst_i32(55102401), unconst_i32(416603131), unconst_i32(-1197845050))))[1])];
  let vf14: f16 = cos(unconst_f16(-5027.4));
  if bool(vf14) {
  if bool(reflect(vec4f(unconst_f32(0.3277), unconst_f32(0.01338), unconst_f32(0.09547e34), unconst_f32(0.6439e0)), vec4f(unconst_f32(0.01062e-3), unconst_f32(0.00968), unconst_f32(-0.03903e1), unconst_f32(0.2251e-20))).w) {
  let vf15: f32 = length(unconst_f32(0.3719e6));
  vp0[1][0].fract *= vp0[unconst_u32(285357098)][unconst_u32(731826027)].fract;
  loop {
  out[unconst_u32(716888710)][unconst_u32(270122213)] = out[u32(out[0][1])][1];
  vp1 &= vec2u(u32(a0));
  vp1 = bitcast<vec2u>(vp0[unconst_u32(748964913)][0].fract.xz);
  break;
}
}
  out[unconst_u32(1530034070)][unconst_u32(365181968)] = f32(tan(vec3h(unconst_f16(13541.4), unconst_f16(28601.6), unconst_f16(4469.0))).z);
  vp0[unconst_u32(910587765)][unconst_u32(141824083)] = frexp(vec3f(tan(vec3h(unconst_f16(5441.7), unconst_f16(3175.0), unconst_f16(8795.9))).xyx));
  let ptr7 = &vp0[unconst_u32(536645373)][unconst_u32(105934369)];
  let vf16: vec3f = tan(vec3f(unconst_f32(0.4245e-42), unconst_f32(0.07037e7), unconst_f32(0.02838e14)));
  return out;
}
  let vf17: vec4<bool> = (vec4i(unconst_i32(166339487), unconst_i32(1313786222), unconst_i32(302977568), unconst_i32(920093798)) <= vec4i(vp0[1][0].fract.bggb));
  let ptr8: ptr<function, array<array<f32, 2>, 1>> = &out;
  vp0[unconst_u32(1285893395)][unconst_u32(1485801944)] = frexp(vec3f((*ptr8)[unconst_u32(1213077896)][1]));
  return out;
}

var<private> vp1: vec2u = vec2u(4294967295, 448672177);

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

var<private> vp0 = array(array(frexp(vec3f(0.2877, 0.02742, 0.1634e14))), array(frexp(vec3f(0.04590, -0.02991, 0.00957e-23))));

@group(0) @binding(90) var st4: texture_storage_2d<rgba16uint, write>;

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

/* zero global variables used */
fn fn2() {
  let vf9: f16 = length(vec2h(unconst_f16(15083.9), unconst_f16(5744.0)));
  vp0[unconst_u32(759008081)][unconst_u32(1062422933)].exp = vec3i(sqrt(vp0[1][0].fract).brg.zxx.zxz.rbr.rbr);
  if bool(vp0[unconst_u32(249742075)][unconst_u32(612554605)].exp.r) {
  let vf10: vec4f = quantizeToF16(vec4f(unconst_f32(0.02923), unconst_f32(0.2791), unconst_f32(0.1635), unconst_f32(0.01274e36)));
  vp1 >>= vec2u(u32(distance(vec4h(f16((unconst_u32(1370164628) == unconst_u32(575277595)))), vec4h(unconst_f16(19482.9), unconst_f16(12393.4), unconst_f16(6962.7), unconst_f16(13596.2)))));
  var vf11: u32 = pack4xI8Clamp(vec4i(unconst_i32(497349684), unconst_i32(60098982), unconst_i32(47614253), unconst_i32(1210204025)));
  var vf12: f32 = saturate(unconst_f32(0.04558e-44));
}
  vp1 = vec2u(vp0[1][unconst_u32(1775333034)].fract.xy.yy.xy.xy);
  vp1 -= bitcast<vec2u>(vp0[1][0].exp.rb.yy);
  for (var it0=vec3u(vp0[unconst_u32(189261392)][0].exp.ggg).b; it0<(vec3u(vp0[unconst_u32(469404829)][0].exp.rgg).z & 0xfff); it0++) {
  let vf13: vec2h = acosh(vec2h(unconst_f16(14038.0), unconst_f16(560.0)));
  vp0[1][unconst_u32(2437800017)] = frexp(bitcast<vec3f>(vp0[unconst_u32(1471447876)][unconst_u32(162995605)].exp.bgb));
  vp0[unconst_u32(780322056)][0].fract = unpack4x8snorm(unconst_u32(446976885)).yyy;
  return;
}
  vp0[unconst_u32(950802038)][0] = vp0[1][0];
  let ptr5 = &vp0[1];
  vp0[unconst_u32(203359195)][unconst_u32(64014613)].exp = (*ptr5)[unconst_u32(1547966962)].exp;
}

/* used global variables: st4 */
@must_use 
fn fn1(a0: ptr<private, vec3i>) -> array<mat4x4f, 1> {
  var out: array<mat4x4f, 1>;
  let ptr3 = &vp0[unconst_u32(993555192)];
  vp1 = bitcast<vec2u>(out[0][unconst_u32(783544599)].xz.yy);
  vp1 >>= vec2u((*ptr3)[unconst_u32(165936720)].fract.bb.xx);
  var vf7: vec4h = normalize(vec4h(unconst_f16(12471.1), unconst_f16(13749.0), unconst_f16(4029.8), unconst_f16(8254.8)));
  var vf8: vec3f = log2(vec3f(unconst_f32(0.04275e12), unconst_f32(0.2881), unconst_f32(0.1232e0)));
  (*a0) *= bitcast<vec3i>(reflect(vec3f(vp0[1][0].exp), vec3f(unconst_f32(0.1785e21), unconst_f32(0.6013), unconst_f32(0.1001))).xyz);
  let ptr4 = &vp0[unconst_u32(16773651)];
  out[unconst_u32(521448238)] = mat4x4f(out[0][unconst_u32(1667317725)], out[0][unconst_u32(1667317725)], out[0][unconst_u32(1667317725)], out[0][unconst_u32(1667317725)]);
  textureStore(st4, vec2i((*ptr3)[unconst_u32(329644261)].fract.yy.gr), vec4u(bitcast<vec4u>(vp0[1][0].fract.xyzx)));
  return out;
  _ = st4;
}

/* zero global variables used */
@must_use 
fn fn0(a0: texture_storage_3d<r32float, read_write>, a1: ptr<storage, T0, read_write>) -> vec4<bool> {
  var out: vec4<bool>;
  textureStore(a0, vec3i(unconst_i32(12729469), unconst_i32(326111007), unconst_i32(184987362)), vec4f(vec4f(unconst_f32(0.06079), unconst_f32(0.1436e-2), unconst_f32(0.2970e3), unconst_f32(0.3146))));
  let ptr2: ptr<storage, atomic<u32>, read_write> = &(*a1).f0;
  vp0[unconst_u32(493079143)][unconst_u32(1573490502)] = frexp(vec3f(faceForward(vec4h(unconst_f16(3221.7), unconst_f16(10951.0), unconst_f16(2370.3), unconst_f16(2428.7)), vec4h(unconst_f16(108.2), unconst_f16(3828.6), unconst_f16(-9571.7), unconst_f16(2063.4)), vec4h(unconst_f16(1404.4), unconst_f16(8847.9), unconst_f16(6799.8), unconst_f16(7732.5))).zzy.xxz.yzz.ggb.bbr));
  return out;
}

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

@id(35769) override override0 = true;

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

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

struct T1 {
  f0: array<vec4<bool>>,
}`,
});
let textureView7 = texture4.createView({dimension: '2d', baseArrayLayer: 0});
let texture15 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder1.setVertexBuffer(0, buffer2, 1_448, 170);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
computePassEncoder1.insertDebugMarker('\u6916');
} catch {}
let pipeline1 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}});
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'pq'} });
try {
externalTexture0.label = '\u2731\u07b7\u0a73\u5549\u0fce\u0ccb';
} catch {}
let texture16 = device0.createTexture({
  size: [1172, 24, 1],
  mipLevelCount: 3,
  format: 'etc2-rgb8a1unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
let buffer9 = device0.createBuffer({size: 700, usage: GPUBufferUsage.VERTEX});
let textureView8 = texture13.createView({baseMipLevel: 0});
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
let videoFrame3 = new VideoFrame(videoFrame1, {timestamp: 0});
let bindGroup0 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 90, resource: textureView8},
    {binding: 1, resource: externalTexture0},
    {binding: 0, resource: textureView1},
    {binding: 3, resource: {buffer: buffer1}},
    {binding: 2, resource: {buffer: buffer1}},
  ],
});
let buffer10 = device0.createBuffer({
  size: 68,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder5 = device0.createCommandEncoder({label: '\ue527\u6037'});
let texture17 = device0.createTexture({
  size: {width: 816, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({
  label: '\u35c1\u63e8\u0ffe\ufade\u0c62\u8951\u77d7\u2f17',
  colorFormats: ['r16uint'],
  stencilReadOnly: true,
});
try {
computePassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
commandEncoder2.clearBuffer(buffer10);
} catch {}
let buffer11 = device0.createBuffer({
  size: 3408,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture18 = device0.createTexture({
  size: {width: 816, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  dimension: '2d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture19 = device0.createTexture({
  size: [2976, 12, 1],
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(6, buffer1, 0, 32);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
computePassEncoder2.insertDebugMarker('\udff9');
} catch {}
try {
device0.queue.writeBuffer(buffer10, 12, new DataView(new ArrayBuffer(30296)), 2551, 4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder6 = device0.createCommandEncoder({});
let texture20 = device0.createTexture({
  size: [2976, 12, 1],
  format: 'astc-4x4-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView9 = texture8.createView({});
let computePassEncoder3 = commandEncoder3.beginComputePass();
try {
commandEncoder6.copyBufferToBuffer(buffer2, 540, buffer11, 456, 312);
} catch {}
let bindGroup1 = device0.createBindGroup({
  label: '\u{1fd35}\u0e68\u{1fa4e}\u04d0\u003d\u{1f9d6}\uc696',
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 2, resource: {buffer: buffer1, offset: 0}},
    {binding: 1, resource: externalTexture0},
    {binding: 3, resource: {buffer: buffer11, offset: 0}},
    {binding: 0, resource: textureView0},
    {binding: 90, resource: textureView8},
  ],
});
let buffer12 = device0.createBuffer({size: 44, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture21 = device0.createTexture({
  size: [360, 210, 1],
  sampleCount: 1,
  format: 'astc-6x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 2, resource: {buffer: buffer1}},
    {binding: 1, resource: externalTexture0},
    {binding: 0, resource: textureView0},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer11}},
  ],
});
let commandEncoder7 = device0.createCommandEncoder({});
let texture22 = device0.createTexture({
  size: [45, 26, 1],
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
try {
computePassEncoder3.setBindGroup(0, bindGroup2, new Uint32Array(499), 14, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); };
} catch {}
try {
commandEncoder5.copyBufferToBuffer(buffer10, 8, buffer11, 276, 0);
} catch {}
try {
commandEncoder2.copyBufferToTexture({
  /* bytesInLastRow: 216 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 336 */
  offset: 336,
  buffer: buffer2,
}, {
  texture: texture16,
  mipLevel: 1,
  origin: {x: 48, y: 4, z: 0},
  aspect: 'all',
}, {width: 108, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder8 = device0.createCommandEncoder();
let texture23 = device0.createTexture({
  size: [1172, 24, 1],
  mipLevelCount: 5,
  format: 'astc-4x4-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder4 = commandEncoder8.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer10, 24); };
} catch {}
let buffer13 = device0.createBuffer({size: 16, usage: GPUBufferUsage.VERTEX});
let textureView10 = texture6.createView({dimension: '2d-array', mipLevelCount: 1});
let textureView11 = texture11.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
computePassEncoder1.setBindGroup(0, bindGroup1, new Uint32Array(1071), 78, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer10, 8); };
} catch {}
try {
computePassEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(8806), 1_078, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer11, 'uint16', 980, 87);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(1, buffer0, 0, 1);
} catch {}
try {
renderBundleEncoder0.pushDebugGroup('\u{1fac9}');
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 2, resource: {buffer: buffer11}},
    {binding: 1, resource: externalTexture0},
    {binding: 0, resource: textureView0},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer11}},
  ],
});
let buffer14 = device0.createBuffer({size: 320, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder9 = device0.createCommandEncoder({});
let texture24 = device0.createTexture({
  size: {width: 204, height: 1, depthOrArrayLayers: 30},
  mipLevelCount: 3,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 1); };
} catch {}
let texture25 = device0.createTexture({
  size: [1488, 6, 1],
  format: 'astc-8x6-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView12 = texture15.createView({baseMipLevel: 0});
let texture26 = device0.createTexture({
  size: [372, 1, 1],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder0 = commandEncoder7.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: -484.0, g: -602.5, b: -615.5, a: -284.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder3.setBindGroup(1, bindGroup0, new Uint32Array(1872), 192, 0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup1);
} catch {}
let bindGroup4 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 3, resource: {buffer: buffer1}},
    {binding: 2, resource: {buffer: buffer11}},
    {binding: 1, resource: externalTexture0},
    {binding: 90, resource: textureView8},
    {binding: 0, resource: textureView1},
  ],
});
let commandEncoder10 = device0.createCommandEncoder();
let textureView13 = texture22.createView({dimension: '2d-array'});
let renderPassEncoder1 = commandEncoder6.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: -48.59, g: 976.3, b: -553.8, a: -53.19, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['r16uint']});
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(6066), 1_812, 0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(3, buffer11, 0, 130);
} catch {}
try {
computePassEncoder2.insertDebugMarker('\u03d5');
} catch {}
await gc();
let texture27 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  format: 'astc-12x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture28 = device0.createTexture({
  size: [64, 64, 20],
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder2 = commandEncoder2.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: -625.3, g: -325.9, b: 552.4, a: -475.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(1105), 146, 0);
} catch {}
try {
computePassEncoder3.end();
} catch {}
let texture29 = device0.createTexture({
  size: [2976, 12, 1],
  mipLevelCount: 2,
  format: 'eac-r11snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture30 = device0.createTexture({
  size: {width: 1172, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView14 = texture16.createView({mipLevelCount: 1});
let renderPassEncoder3 = commandEncoder3.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: 892.0, g: 843.1, b: -804.8, a: 985.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup1, new Uint32Array(1590), 578, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer11, 'uint32', 816, 422);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 323, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup5 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 2, resource: {buffer: buffer11}},
    {binding: 0, resource: textureView1},
    {binding: 3, resource: {buffer: buffer1}},
    {binding: 90, resource: textureView8},
    {binding: 1, resource: externalTexture0},
  ],
});
let texture31 = device0.createTexture({
  size: [204, 1, 8],
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setBindGroup(1, bindGroup4);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder0.end();
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer0, 'uint16', 0, 0);
} catch {}
try {
renderBundleEncoder0.popDebugGroup();
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

enable f16;

struct VertexOutput1 {
  @location(10) @interpolate(perspective, centroid) location_10: f32,
  @location(9) @interpolate(perspective, first) location_9: vec4f,
  @location(4) location_4: i32,
  @builtin(position) position: vec4f,
  @location(1) @interpolate(perspective, first) location_1: vec2h,
}

struct T7 {
  f0: array<T0, 1>,
}

struct T9 {
  f0: array<f32, 1>,
  f1: array<u32>,
}

struct T5 {
  f0: array<vec2h, 1>,
  f1: T4,
}

struct VertexInput8 {
  @builtin(instance_index) instance_index: u32,
  @location(1) @interpolate(flat) location_1: vec4h,
}

struct T0 {
  @size(12) f0: array<atomic<i32>, 1>,
}

struct T13 {
  f0: T9,
}

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

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

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

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

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

struct FragmentInput0 {
  @location(4) location_4: i32,
}

struct T12 {
  @size(2368) f0: vec4h,
  @size(64) f1: bool,
  @align(8) @size(256) f2: array<array<array<array<u32, 1>, 1>, 16>, 2>,
  @size(64) f3: vec2f,
  @size(64) f4: array<array<array<array<array<bool, 1>, 1>, 4>, 1>, 1>,
  @align(64) @size(64) f5: i32,
}

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

override override2: u32;

struct T2 {
  f0: array<vec2h>,
}

@group(0) @binding(2) var<storage, read_write> buffer15: T0;

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

struct T11 {
  @align(8) f0: T2,
}

var<private> vp2 = array(modf(vec2f(0.2609, 0.08606e-35)), modf(vec2f(-0.1048e2, 0.2992)), modf(vec2f(0.2782e-26, 0.2266)), modf(vec2f(-0.05900e38, -0.04548e28)), modf(vec2f(-0.09789e0, 0.01944)), modf(vec2f(0.2434, 0.2502e-21)), modf(vec2f(0.1448, 0.06285)), modf(vec2f(0.02884e20, 0.04595e25)), modf(vec2f(0.4101e21, 0.1323)), modf(vec2f(0.1590e3, 0.4296e-41)), modf(vec2f(0.7237e6, -0.09288)));

struct T10 {
  f0: T5,
}

struct FragmentOutput0 {
  @location(2) location_2: vec2u,
  @location(0) @interpolate(flat, sample) location_0: vec4u,
}

struct T3 {
  @size(8192) f0: mat2x2f,
}

struct T8 {
  @align(8) @size(56) f0: T7,
}

struct T6 {
  f0: T4,
}

@group(0) @binding(3) var<storage, read> buffer16: array<array<f16, 28>>;

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

override override1 = 0.01834;

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

struct T4 {
  f0: array<u32>,
}

struct VertexInput7 {
  @location(7) @interpolate(perspective) location_7: f16,
  @location(4) @interpolate(flat, either) location_4: vec2i,
}

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

struct FragmentInput1 {
  @location(9) @interpolate(perspective, first) location_9: vec4f,
}

@group(0) @binding(90) var st6: texture_storage_2d<rgba16uint, write>;

alias vec3b = vec3<bool>;

var<workgroup> vw1: vec4i;

/* zero global variables used */
@vertex
fn vertex1(a0: VertexInput7, a1: VertexInput8) -> VertexOutput1 {
  var out: VertexOutput1;
  let vf18: vec4<bool> = (vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) | vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true), unconst_bool(false)));
  let vf19: bool = (unconst_u32(1021466753) > u32(a0.location_7));
  return out;
}

/* used global variables: st6 */
@fragment
fn fragment0(@location(10) location_10: f32, a1: FragmentInput0, a2: FragmentInput1, @location(1) location_1: vec2h, @builtin(position) position: vec4f, a5: FragmentInput2) -> FragmentOutput0 {
  var out: FragmentOutput0;
  let ptr9: ptr<private, vec2f> = &vp2[10].whole;
  vp2[unconst_u32(221662116)].whole -= bitcast<vec2f>(atan(vec4h(unconst_f16(10782.0), unconst_f16(29354.2), unconst_f16(1967.7), unconst_f16(13122.5))));
  var vf20: vec2f = radians(vec2f(unconst_f32(0.2483), unconst_f32(0.1562e-43)));
  let vf21: u32 = out.location_0[unconst_u32(439377578)];
  textureStore(st6, vec2i(unconst_i32(183714202), unconst_i32(219185696)), vec4u(vec4u(u32(a1.location_4))));
  return out;
  _ = st6;
}

/* used global variables: buffer15, buffer16 */
@compute @workgroup_size(3, 1, 2)
fn compute1(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, a2: ComputeInput2, a3: ComputeInput3, a4: ComputeInput4) {
  for (var jj36=0u; jj36<3; jj36++) { atomicExchange(&buffer15.f0[jj36], unconst_i32(16397202)); }
  let ptr10: ptr<storage, atomic<i32>, read_write> = &(*&buffer15).f0[0];
  var vf22: i32 = atomicExchange(&(*&buffer15).f0[unconst_u32(265286985)], unconst_i32(267928938));
  let ptr11: ptr<storage, f16, read> = &buffer16[unconst_u32(559958333)][unconst_u32(201964716)];
  vw1 = vec4i(a2.num_workgroups.zxxz.rbar);
  vw1 &= vec4i(bitcast<i32>(arrayLength(&(*&buffer16))));
  let ptr12: ptr<storage, f16, read> = &buffer16[arrayLength(&buffer16)][27];
  _ = buffer15;
  _ = buffer16;
}`,
});
let commandEncoder11 = device0.createCommandEncoder({label: '\u8dba\uc62a\u{1fb3c}\ueab5\u14c4'});
let texture32 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(709), 35, 0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup1);
} catch {}
try {
commandEncoder5.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2624 */
  offset: 2624,
  buffer: buffer2,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 15, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData0 = new ImageData(132, 168);
let buffer17 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let texture33 = device0.createTexture({
  size: [360, 210, 1],
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture34 = device0.createTexture({
  size: [204, 1, 1],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup4);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
computePassEncoder1.end();
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(818), 38, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer11, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(4, buffer9);
} catch {}
try {
commandEncoder1.copyBufferToBuffer(buffer2, 5064, buffer11, 160, 1388);
} catch {}
try {
device0.queue.writeBuffer(buffer17, 8, new DataView(new Uint8Array(5934).map((_, i) => i).buffer), 63, 40);
} catch {}
let pipeline2 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}});
let buffer18 = device0.createBuffer({size: 112, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder12 = device0.createCommandEncoder({});
let texture35 = device0.createTexture({
  size: {width: 586, height: 12, depthOrArrayLayers: 1},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder4 = commandEncoder1.beginRenderPass({
  label: '\u{1f6a3}\u{1f766}\u8d78\uc7fa\u{1fd8d}\u04bd\u06b2\u4b3a\u05b6\u{1f763}',
  colorAttachments: [{view: textureView12, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 103069403,
});
try {
renderPassEncoder2.setIndexBuffer(buffer0, 'uint16', 0, 1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer0, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer18, 'uint16', 28, 9);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(4, buffer1, 0, 6);
} catch {}
try {
commandEncoder5.copyTextureToTexture({
  texture: texture11,
  mipLevel: 2,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture11,
  mipLevel: 0,
  origin: {x: 620, y: 0, z: 0},
  aspect: 'all',
},
{width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u98ce');
} catch {}
let texture36 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 9},
  format: 'rg8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(1885), 140, 0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(6, buffer11);
} catch {}
let commandEncoder13 = device0.createCommandEncoder();
let texture37 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  format: 'etc2-rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer2, 0, 5_535);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup5, []);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer11, 'uint16', 1_412, 383);
} catch {}
try {
commandEncoder11.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 40, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1632 widthInBlocks: 102 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1040 */
  offset: 1040,
  bytesPerRow: 2560,
  rowsPerImage: 1144,
  buffer: buffer11,
}, {width: 408, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 0, new DataView(new ArrayBuffer(2608)), 19, 0);
} catch {}
try {
adapter0.label = '\uabe9\u{1f828}';
} catch {}
let bindGroup6 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 0, resource: textureView0},
    {binding: 1, resource: externalTexture0},
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer1}},
  ],
});
let texture38 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'astc-6x6-unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder4.setBindGroup(1, bindGroup4);
} catch {}
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
let commandEncoder14 = device0.createCommandEncoder({});
let texture39 = device0.createTexture({
  size: [293, 6, 1],
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
try {
computePassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(392), 48, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer12, 8, 1);
} catch {}
let promise0 = device0.queue.onSubmittedWorkDone();
let texture40 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'astc-5x5-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setBindGroup(0, bindGroup5, []);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup6);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
commandEncoder5.copyBufferToBuffer(buffer17, 4, buffer11, 672, 16);
} catch {}
try {
  await promise0;
} catch {}
let texture41 = device0.createTexture({
  size: {width: 816, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView15 = texture41.createView({mipLevelCount: 1});
let renderPassEncoder5 = commandEncoder5.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: -687.4, g: 454.1, b: -620.5, a: -96.66, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 0);
} catch {}
let commandEncoder15 = device0.createCommandEncoder({});
let texture42 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 20},
  dimension: '2d',
  format: 'eac-rg11unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder7.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup4, new Uint32Array(167), 27, 0);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(6, buffer2);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\u848d');
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 2, resource: {buffer: buffer1, offset: 0}},
    {binding: 1, resource: externalTexture0},
    {binding: 90, resource: textureView8},
    {binding: 0, resource: textureView1},
  ],
});
let commandEncoder16 = device0.createCommandEncoder();
let texture43 = device0.createTexture({
  size: [1172, 24, 1],
  mipLevelCount: 3,
  format: 'etc2-rgb8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder6 = commandEncoder11.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: 287.7, g: -348.7, b: -181.1, a: -707.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder4.setBindGroup(0, bindGroup3);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5, buffer0, 4, 2);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let textureView16 = texture42.createView({dimension: 'cube-array', baseArrayLayer: 3, arrayLayerCount: 6});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup7, new Uint32Array(851), 2, 0);
} catch {}
try {
commandEncoder13.copyTextureToBuffer({
  texture: texture12,
  mipLevel: 1,
  origin: {x: 25, y: 5, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 64 widthInBlocks: 32 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 608 */
  offset: 608,
  bytesPerRow: 31488,
  buffer: buffer11,
}, {width: 32, height: 15, depthOrArrayLayers: 0});
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let textureView17 = texture39.createView({baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder5 = commandEncoder15.beginComputePass();
try {
computePassEncoder5.setBindGroup(3, bindGroup2);
} catch {}
try {
computePassEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(69), 0, 0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup5);
} catch {}
let buffer19 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder18 = device0.createCommandEncoder();
let renderPassEncoder7 = commandEncoder13.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: 694.6, g: -209.6, b: 411.7, a: -189.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 22325823,
});
try {
renderBundleEncoder7.setVertexBuffer(0, buffer12);
} catch {}
try {
texture5.destroy();
} catch {}
try {
buffer11.unmap();
} catch {}
let texture44 = device0.createTexture({
  size: {width: 90, height: 52, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder2.setVertexBuffer(7, buffer9);
} catch {}
let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(0);
let commandEncoder19 = device0.createCommandEncoder({});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 2363});
let textureView18 = texture15.createView({});
let externalTexture1 = device0.importExternalTexture({source: videoFrame1});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1, 3); };
} catch {}
try {
commandEncoder0.resolveQuerySet(querySet0, 566, 15, buffer14, 0);
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint16', 0, 3);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup2);
} catch {}
let pipeline3 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
let texture45 = device0.createTexture({size: [360, 210, 14], dimension: '3d', format: 'r16uint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView19 = texture11.createView({mipLevelCount: 1, baseArrayLayer: 0});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['r16uint']});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer18, 28); };
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.writeBuffer(buffer17, 44, new Uint32Array(16935).map((_, i) => i * 7), 650, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 408, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 1,
  origin: {x: 64, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer20 = device0.createBuffer({size: 144, usage: GPUBufferUsage.UNIFORM});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer10, 0); };
} catch {}
let commandBuffer0 = commandEncoder0.finish();
let texture46 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 9},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1); };
} catch {}
let commandEncoder21 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder5.setBindGroup(0, bindGroup6, new Uint32Array(3421), 124, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer2, 0, 1_626);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer18, 'uint32', 4, 46);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder18.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2840 */
  offset: 2840,
  buffer: buffer2,
}, {
  texture: texture29,
  mipLevel: 1,
  origin: {x: 40, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 0, new DataView(new ArrayBuffer(29532)), 2644, 0);
} catch {}
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {binding: 52, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
  ],
});
let computePassEncoder6 = commandEncoder16.beginComputePass();
try {
computePassEncoder2.setBindGroup(1, bindGroup1, new Uint32Array(511), 183, 0);
} catch {}
try {
computePassEncoder4.end();
} catch {}
try {
computePassEncoder6.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setStencilReference(190);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer0, 'uint16', 0, 0);
} catch {}
let autogeneratedBindGroupLayout0 = pipeline3.getBindGroupLayout(0);
let bindGroup8 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 2, resource: {buffer: buffer11}},
    {binding: 90, resource: textureView8},
    {binding: 0, resource: textureView0},
    {binding: 1, resource: externalTexture1},
    {binding: 3, resource: {buffer: buffer1}},
  ],
});
let buffer21 = device0.createBuffer({size: 100, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let commandEncoder22 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(0, bindGroup2, []);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup4, new Uint32Array(497), 106, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer17, 'uint16', 2, 0);
} catch {}
let img0 = await imageWithData(9, 5, '#10101010', '#20202020');
let bindGroup9 = device0.createBindGroup({
  label: '\u{1fe66}\u{1ffec}\u978c\ueb88\u9721\u1b05\u08aa',
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 2, resource: {buffer: buffer1}}],
});
let texture47 = device0.createTexture({
  size: [293, 6, 102],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder8 = commandEncoder20.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: -162.1, g: 247.4, b: -998.6, a: 658.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder8.setBindGroup(1, bindGroup6);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder18.copyTextureToBuffer({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 127, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 13792 widthInBlocks: 862 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3376 */
  offset: 3376,
  bytesPerRow: 15104,
  buffer: buffer11,
}, {width: 862, height: 15, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.resolveQuerySet(querySet0, 543, 0, buffer19, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 96, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline4 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 4, shaderLocation: 7},
          {format: 'snorm16x2', offset: 0, shaderLocation: 1},
          {format: 'sint8x4', offset: 12, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', unclippedDepth: true},
});
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpteRp431', transfer: 'smpteSt4281'} });
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let buffer22 = device0.createBuffer({size: 92, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder23 = device0.createCommandEncoder();
try {
renderPassEncoder5.setVertexBuffer(6, buffer11, 248, 698);
} catch {}
let bindGroup10 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 1, resource: externalTexture1},
    {binding: 0, resource: textureView1},
    {binding: 2, resource: {buffer: buffer22}},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer22}},
  ],
});
let commandEncoder24 = device0.createCommandEncoder({});
try {
renderPassEncoder0.setVertexBuffer(1, buffer22, 20);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup2, new Uint32Array(1149), 646, 0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer18, 'uint16', 62, 5);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(6, buffer22, 0);
} catch {}
document.body.prepend(img0);
let buffer23 = device0.createBuffer({size: 14668, usage: GPUBufferUsage.MAP_READ});
let commandEncoder25 = device0.createCommandEncoder();
let textureView20 = texture31.createView({arrayLayerCount: 1});
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
await gc();
let commandEncoder26 = device0.createCommandEncoder({});
let textureView21 = texture3.createView({dimension: '2d', format: 'r32sint', mipLevelCount: 1, baseArrayLayer: 10});
let textureView22 = texture1.createView({mipLevelCount: 1});
try {
computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(4055), 352, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(5, buffer13, 0);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline4);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let bindGroup11 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: externalTexture1},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer22}},
    {binding: 0, resource: textureView1},
    {binding: 2, resource: {buffer: buffer11}},
  ],
});
let texture48 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['r16uint']});
try {
computePassEncoder6.setBindGroup(1, bindGroup10, []);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer17, 'uint32', 8, 2);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, buffer1);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup4, new Uint32Array(484), 26, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer0, 'uint16', 2, 2);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
let shaderModule3 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

enable f16;

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

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

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

@group(1) @binding(1) var et5: texture_external;

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

/* zero global variables used */
@must_use 
fn fn1(a0: array<array<T0, 1>, 1>) -> array<T0, 2> {
  var out: array<T0, 2>;
  vp3 = modf(f32(a0[0][0].f0[0][0][unconst_u32(210057444)][unconst_u32(743443354)][0]));
  return out;
}

struct T7 {
  f0: array<array<vec2u, 1>>,
}

struct T3 {
  f0: T2,
}

/* used global variables: et4, et5 */
fn fn0(a0: texture_external) {
  vp3.whole = f32(unconst_f32(0.07846e34));
  let vf23: vec2u = textureDimensions(et4);
  vp3.whole *= f32(unconst_f32(0.2565e25));
  vp3.whole -= bitcast<f32>(vf23[unconst_u32(20935369)]);
  vp3 = modf(vp3.fract);
  let ptr13: ptr<private, f32> = &vp3.fract;
  while bool(textureDimensions(et4).x) {
  vp3 = modf(f32(any(vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(true)))));
  _ = et4;
  _ = et4;
}
  switch pack4xU8(bitcast<vec4u>(textureLoad(et5, vec2u(unconst_u32(1062078441), unconst_u32(359419000))))) { 
  case 259842873, default {
  vp3.fract += vec3f((unconst_f16(3751.4) % vec3h(f16(pack4xU8(vec4u(unconst_u32(189094945), unconst_u32(618342912), unconst_u32(977863790), unconst_u32(93121286)))))).rgb.xzx)[0];
  vp3.whole = vec3f((unconst_f16(4102.6) % vec3h(unconst_f16(19801.6), unconst_f16(21977.3), unconst_f16(32044.1))).bgg).b;
  let vf24: vec2u = textureDimensions(et4);
  let vf25: vec2u = textureDimensions(et5);
  _ = et4;
  _ = et5;
}
  }
  _ = a0;
  vp3 = modf(bitcast<f32>(vf23[unconst_u32(970055881)]));
  return;
  _ = et5;
  _ = et4;
}

var<workgroup> vw2: atomic<u32>;

/* used global variables: st10, st8 */
fn fn2(a0: texture_storage_2d<rgba16uint, write>) -> array<u32, 46> {
  var out: array<u32, 46>;
  vp3.whole = f32(length(vec3h(unconst_f16(1917.8), unconst_f16(2210.2), unconst_f16(19064.2))));
  var vf26: vec2u = (unconst_u32(274389211) + vec2u(unconst_u32(2251429372), unconst_u32(13032698)));
  var vf27: bool = (unconst_u32(8822480) <= unconst_u32(719795722));
  let vf28: vec4<bool> = (vec4h(unconst_f16(3053.2), unconst_f16(4901.4), unconst_f16(6478.4), unconst_f16(12245.3)) >= vec4h(unconst_f16(682.3), unconst_f16(44394.2), unconst_f16(4183.5), unconst_f16(7155.1)));
  var vf29: vec3<bool> = (vec3f(unconst_f32(0.01212e26), unconst_f32(0.1354), unconst_f32(0.02204)) < vec3f(unconst_f32(0.01944), unconst_f32(-0.00361e16), unconst_f32(0.3116e4)));
  while all(vf28) {
  out[unconst_u32(241364278)] = bitcast<u32>(vp3.fract);
  _ = st10;
  textureStore(a0, vec2i(unconst_i32(-633635256), unconst_i32(624440776)), vec4u(vec4u(unconst_u32(833130464), unconst_u32(922940171), unconst_u32(1473974269), unconst_u32(7643545))));
  break;
  _ = st10;
}
  var vf30: vec3f = tan(vec3f((vec3h(unconst_f16(-2859.8), unconst_f16(611.7), unconst_f16(2431.9)) < vec3h(unconst_f16(3993.1), unconst_f16(21694.1), unconst_f16(8326.3))).xxy));
  vf29 = vec3<bool>(bool(length(vec3h(unconst_f16(11130.2), unconst_f16(16898.8), unconst_f16(11683.7)))));
  vf30 *= vec3f((mat4x2h(unconst_f16(35381.6), unconst_f16(3887.9), unconst_f16(15406.2), unconst_f16(20983.9), unconst_f16(1798.6), unconst_f16(10234.4), unconst_f16(3018.0), unconst_f16(31922.4)) + mat4x2h(unconst_f16(2973.9), unconst_f16(35964.7), unconst_f16(-4175.0), unconst_f16(571.1), unconst_f16(6477.8), unconst_f16(18662.7), unconst_f16(10197.2), unconst_f16(5443.0)))[unconst_i32(0)].rrr.xxz);
  textureStore(st8, vec2i(unconst_i32(133981904), unconst_i32(366660987)), vec4u(vec4u(unconst_u32(1134649703), unconst_u32(45964184), unconst_u32(2351167009), unconst_u32(1740993443))));
  switch i32((unconst_bool(false) & unconst_bool(false))) { 
  case default {
  var vf31: f16 = log(unconst_f16(22.42));
  var vf32: vec3i = (unconst_i32(1456970376) * vec3i(unconst_i32(9421847), unconst_i32(171185491), unconst_i32(14615558)));
  var vf33: bool = any(vec2<bool>(unconst_bool(false), unconst_bool(true)));
  _ = st8;
  while bool(abs(vec3f(f32(log(unconst_f16(11260.1)))))[0]) {
  out[unconst_u32(459723162)] *= bitcast<u32>(vp3.fract);
}
  vf32 *= vec3i(vf32[unconst_u32(34319070)]);
  break;
  _ = st8;
}
  }
  return out;
  _ = st8;
  _ = st10;
}

struct T1 {
  f0: array<bool>,
}

@group(0) @binding(90) var st8: texture_storage_2d<rgba16uint, write>;

@group(1) @binding(90) var st10: texture_storage_2d<rgba16uint, write>;

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

struct T4 {
  f0: array<u32>,
}

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

var<private> vp3 = modf(f32(0.1482));

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

struct T0 {
  @size(12) f0: array<array<array<array<array<i32, 1>, 1>, 1>, 1>, 1>,
}

struct T6 {
  f0: array<bool>,
}

@group(0) @binding(1) var et4: texture_external;

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

struct T8 {
  f0: T3,
}

alias vec3b = vec3<bool>;`,
});
let bindGroup12 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 3, resource: {buffer: buffer11, offset: 768}},
    {binding: 2, resource: {buffer: buffer22}},
    {binding: 1, resource: externalTexture0},
    {binding: 90, resource: textureView8},
    {binding: 0, resource: textureView1},
  ],
});
let commandEncoder27 = device0.createCommandEncoder({});
let texture49 = device0.createTexture({size: [408, 1, 1], format: 'r16uint', usage: GPUTextureUsage.COPY_DST});
let renderPassEncoder9 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: -857.8, g: -903.1, b: -393.3, a: 229.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 445565033,
});
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 0, resource: textureView0},
    {binding: 3, resource: {buffer: buffer10}},
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer22}},
    {binding: 1, resource: externalTexture0},
  ],
});
let textureView23 = texture41.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder2.setBindGroup(1, bindGroup10, new Uint32Array(1567), 146, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer18, 'uint32', 4, 4);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(6, buffer11);
} catch {}
try {
computePassEncoder5.setBindGroup(1, bindGroup6, new Uint32Array(290), 12, 0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(1, buffer0, 0);
} catch {}
let commandEncoder28 = device0.createCommandEncoder({});
let textureView24 = texture18.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
let renderPassEncoder10 = commandEncoder28.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: 48.21, g: 151.8, b: 431.3, a: -213.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 250440206,
});
try {
renderBundleEncoder2.setBindGroup(3, bindGroup13, new Uint32Array(3113), 354, 0);
} catch {}
let textureView25 = texture27.createView({dimension: '2d-array'});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder7.setBindGroup(1, bindGroup13);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer2);
} catch {}
let textureView26 = texture44.createView({dimension: '2d-array'});
let textureView27 = texture18.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder0.setBindGroup(3, bindGroup6, new Uint32Array(1751), 133, 0);
} catch {}
try {
renderPassEncoder10.beginOcclusionQuery(2241);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3, buffer2, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer17, 'uint32', 4, 1);
} catch {}
try {
commandEncoder8.clearBuffer(buffer11);
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 1, resource: externalTexture1},
    {binding: 3, resource: {buffer: buffer1}},
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer10}},
    {binding: 0, resource: textureView0},
  ],
});
let texture50 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture51 = device0.createTexture({
  size: {width: 180},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView28 = texture50.createView({});
let sampler0 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  lodMaxClamp: 72.43,
  compare: 'always',
});
try {
computePassEncoder6.setBindGroup(3, bindGroup7);
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 3, resource: {buffer: buffer11, size: 244}},
    {binding: 1, resource: externalTexture1},
    {binding: 2, resource: {buffer: buffer22}},
    {binding: 0, resource: textureView1},
    {binding: 90, resource: textureView8},
  ],
});
let commandEncoder29 = device0.createCommandEncoder({});
let textureView29 = texture22.createView({dimension: '2d'});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({
  label: '\u1178\u05ae\uf253\ufa8c\u9652\u3f69\ue6c7\u42dc',
  colorFormats: ['r16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
device0.queue.writeBuffer(buffer10, 8, new DataView(new ArrayBuffer(22784)), 625, 0);
} catch {}
let imageData1 = new ImageData(40, 76);
let buffer28 = device0.createBuffer({
  size: 284,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let commandEncoder30 = device0.createCommandEncoder({});
let texture52 = device0.createTexture({size: [2976], dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_DST});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['r16uint']});
await gc();
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpte240m', transfer: 'logSqrt'} });
let texture53 = device0.createTexture({
  size: {width: 372, height: 1, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder8.setVertexBuffer(6, buffer22, 12);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 159, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData2 = new ImageData(4, 4);
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
    {binding: 1, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 90,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let textureView30 = texture17.createView({mipLevelCount: 1});
try {
computePassEncoder6.setBindGroup(2, bindGroup14);
} catch {}
try {
commandEncoder12.copyBufferToTexture({
  /* bytesInLastRow: 72 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 640 */
  offset: 640,
  bytesPerRow: 25088,
  rowsPerImage: 318,
  buffer: buffer2,
}, {
  texture: texture16,
  mipLevel: 1,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {width: 36, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder2.insertDebugMarker('\ue4ed');
} catch {}
let computePassEncoder7 = commandEncoder24.beginComputePass();
try {
computePassEncoder7.setBindGroup(3, bindGroup8, new Uint32Array(2777), 195, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder7.setPipeline(pipeline2);
} catch {}
let pipeline5 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute1', constants: {}}});
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'smpte170m'} });
let bindGroup16 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: externalTexture1},
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer11}},
    {binding: 3, resource: {buffer: buffer11, offset: 0}},
    {binding: 0, resource: textureView0},
  ],
});
try {
computePassEncoder5.setBindGroup(1, bindGroup1, new Uint32Array(2452), 193, 0);
} catch {}
try {
computePassEncoder5.end();
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture18,
  mipLevel: 1,
  origin: {x: 37, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(263).fill(4), /* required buffer size: 263 */
{offset: 263}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderPassEncoder11 = commandEncoder17.beginRenderPass({
  colorAttachments: [{view: textureView18, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 202188487,
});
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder10.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer18, 'uint16', 0, 27);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer12, 4, 1);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline4);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder8.copyBufferToTexture({
  /* bytesInLastRow: 406 widthInBlocks: 203 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2326 */
  offset: 2326,
  bytesPerRow: 19456,
  buffer: buffer2,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 646, y: 0, z: 0},
  aspect: 'all',
}, {width: 203, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder18.copyTextureToBuffer({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 288, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 112 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 128 */
  offset: 128,
  buffer: buffer28,
}, {width: 56, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer11, 768, new Float16Array(18629).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.9656)), 3125, 324);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let recycledExplicitBindGroupLayout1 = pipeline4.getBindGroupLayout(1);
let bindGroup17 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 407, resource: {buffer: buffer11, size: 412}},
    {binding: 0, resource: {buffer: buffer28}},
    {binding: 11, resource: textureView7},
    {binding: 8, resource: {buffer: buffer28}},
    {binding: 5, resource: textureView16},
    {binding: 3, resource: textureView4},
  ],
});
let sampler1 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMaxClamp: 74.96,
});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer18, 20); };
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer11, 'uint16', 1_198, 253);
} catch {}
let commandBuffer1 = commandEncoder4.finish();
let texture54 = device0.createTexture({
  size: {width: 102, height: 1, depthOrArrayLayers: 28},
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture55 = device0.createTexture({
  size: [102, 1, 76],
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView31 = texture17.createView({mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder8 = commandEncoder29.beginComputePass();
try {
renderPassEncoder5.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer12, 0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup7, new Uint32Array(1902), 1_209, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 8, new DataView(new ArrayBuffer(48280)), 717, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 102, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer29 = device0.createBuffer({size: 548, usage: GPUBufferUsage.INDIRECT});
let commandEncoder31 = device0.createCommandEncoder({});
let textureView32 = texture54.createView({dimension: '2d', baseArrayLayer: 4});
let computePassEncoder9 = commandEncoder19.beginComputePass();
try {
computePassEncoder9.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer2, 992, 181);
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup6);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer11, 'uint16', 1_198, 207);
} catch {}
try {
buffer20.unmap();
} catch {}
let pipeline6 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 6, shaderLocation: 4},
          {format: 'unorm8x2', offset: 0, shaderLocation: 1},
          {format: 'unorm16x4', offset: 0, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let videoFrame7 = new VideoFrame(videoFrame2, {timestamp: 0});
let sampler2 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', magFilter: 'linear', minFilter: 'linear'});
try {
computePassEncoder6.setBindGroup(0, bindGroup15, new Uint32Array(39), 6, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup13, new Uint32Array(748), 22, 0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup7, new Uint32Array(39), 16, 0);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer28, 'uint32', 40, 1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer13.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let commandEncoder32 = device0.createCommandEncoder({});
try {
computePassEncoder8.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup5);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline6);
} catch {}
try {
commandEncoder27.resolveQuerySet(querySet0, 12, 0, buffer14, 0);
} catch {}
let texture56 = device0.createTexture({
  size: [180, 105, 1],
  mipLevelCount: 1,
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView33 = texture7.createView({dimension: '2d', format: 'astc-8x6-unorm-srgb', mipLevelCount: 1});
let computePassEncoder10 = commandEncoder15.beginComputePass();
let renderPassEncoder12 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: -221.2, g: 83.77, b: 672.8, a: 295.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler3 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 87.06});
try {
renderBundleEncoder11.setPipeline(pipeline4);
} catch {}
try {
commandEncoder12.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 604 */
  offset: 604,
  bytesPerRow: 19456,
  buffer: buffer2,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 1, y: 7, z: 0},
  aspect: 'all',
}, {width: 2, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer28, 52, new DataView(new Uint8Array(12899).map((_, i) => i).buffer), 1940, 36);
} catch {}
document.body.prepend(img0);
let buffer30 = device0.createBuffer({label: '\u3150\u0138\u0957\u0dfb\ub41c', size: 232, usage: GPUBufferUsage.VERTEX});
try {
renderBundleEncoder7.setIndexBuffer(buffer11, 'uint16', 678, 699);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline4);
} catch {}
try {
  await promise2;
} catch {}
let textureView34 = texture55.createView({dimension: '3d'});
let externalTexture2 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder10.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -944.8, g: 382.6, b: -581.0, a: 492.0, });
} catch {}
document.body.prepend(img0);
let bindGroup18 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 8, resource: {buffer: buffer11}},
    {binding: 11, resource: textureView6},
    {binding: 3, resource: textureView4},
    {binding: 0, resource: {buffer: buffer11}},
    {binding: 407, resource: {buffer: buffer22, offset: 0}},
    {binding: 5, resource: textureView16},
  ],
});
try {
computePassEncoder7.setBindGroup(0, bindGroup11, []);
} catch {}
try {
computePassEncoder7.setBindGroup(1, bindGroup14, new Uint32Array(1022), 169, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(1, bindGroup13);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup6, new Uint32Array(2283), 568, 0);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline6);
} catch {}
let bindGroup19 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 2, resource: {buffer: buffer28}},
    {binding: 1, resource: externalTexture1},
    {binding: 3, resource: {buffer: buffer1}},
    {binding: 90, resource: textureView8},
    {binding: 0, resource: textureView0},
  ],
});
let buffer31 = device0.createBuffer({size: 464, usage: GPUBufferUsage.UNIFORM});
let commandBuffer2 = commandEncoder8.finish();
try {
computePassEncoder6.setBindGroup(2, bindGroup8);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: 964.4, g: -113.7, b: -355.5, a: 895.0, });
} catch {}
try {
renderPassEncoder5.draw(446, 0, 28_236_898);
} catch {}
try {
commandEncoder9.copyTextureToTexture({
  texture: texture18,
  mipLevel: 1,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 0,
  origin: {x: 396, y: 0, z: 0},
  aspect: 'all',
},
{width: 35, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
adapter0.label = '\uf552\uef6b\u43b3\u0c7c\ubf6d\ub722\u64ca\ub010';
} catch {}
let textureView35 = texture4.createView({});
try {
renderPassEncoder5.drawIndexed(30, 0, 33, -2_058_604_193);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer29, 112);
} catch {}
try {
commandEncoder12.clearBuffer(buffer17);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(3).fill(45), /* required buffer size: 3 */
{offset: 3}, {width: 11, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder33 = device0.createCommandEncoder({});
try {
computePassEncoder9.setBindGroup(0, bindGroup13, new Uint32Array(147), 1, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer18, 40); };
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup13, new Uint32Array(1970), 101, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer32 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder34 = device0.createCommandEncoder({});
try {
renderBundleEncoder8.setBindGroup(1, bindGroup2, new Uint32Array(238), 70, 0);
} catch {}
let buffer33 = device0.createBuffer({size: 144, usage: GPUBufferUsage.MAP_WRITE});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
computePassEncoder8.setBindGroup(3, bindGroup11, new Uint32Array(777), 10, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder7.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer18, 'uint16', 44, 12);
} catch {}
let pipeline7 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule2, targets: [{format: 'r16uint', writeMask: GPUColorWrite.GREEN}]},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint16x4', offset: 240, shaderLocation: 4},
          {format: 'float32x3', offset: 340, shaderLocation: 1},
          {format: 'snorm8x4', offset: 324, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {unclippedDepth: false},
});
let autogeneratedBindGroupLayout1 = pipeline3.getBindGroupLayout(0);
let commandEncoder35 = device0.createCommandEncoder({});
let renderPassEncoder13 = commandEncoder12.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: 189.7, g: -580.0, b: -429.4, a: -235.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 42718794,
});
let externalTexture3 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder8.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer28, 'uint32', 4, 14);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer9, 76);
} catch {}
try {
device0.queue.writeBuffer(buffer32, 44, new Uint32Array(16013).map((_, i) => i * 2), 20, 0);
} catch {}
let commandBuffer3 = commandEncoder5.finish();
let computePassEncoder11 = commandEncoder25.beginComputePass();
try {
computePassEncoder7.setBindGroup(3, bindGroup5);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer17, 'uint16', 74, 7);
} catch {}
try {
device0.queue.submit([commandBuffer2, commandBuffer3]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(65).fill(32), /* required buffer size: 65 */
{offset: 65}, {width: 8, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
globalThis.someLabel = textureView23.label;
} catch {}
let buffer34 = device0.createBuffer({
  label: '\u{1f94b}\ufab5\ub034\uf8f5\u0abc\u3273\u{1f605}\u6f1c\uc0c3\u{1ff21}',
  size: 268,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let texture57 = device0.createTexture({
  label: '\u2bd9\u5ba8\u6b5b\u02f8\u5670',
  size: {width: 204, height: 1, depthOrArrayLayers: 78},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder8.setBindGroup(0, bindGroup4, new Uint32Array(589), 51, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer0, 'uint16', 0, 1);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer9);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 3008 widthInBlocks: 1504 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 434 */
  offset: 434,
  bytesPerRow: 10496,
  buffer: buffer2,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 391, y: 0, z: 0},
  aspect: 'all',
}, {width: 1504, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer32, 4, new DataView(new Uint8Array(1230).map((_, i) => i).buffer), 376, 32);
} catch {}
let textureView36 = texture41.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder4.setBindGroup(0, bindGroup19, new Uint32Array(3915), 820, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer11, 'uint16', 104, 550);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer2, 1_572, 2_526);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer11, 'uint32', 80, 1_025);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 560, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(132).fill(228), /* required buffer size: 132 */
{offset: 132}, {width: 578, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline8 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}});
let commandEncoder36 = device0.createCommandEncoder({});
let textureView37 = texture42.createView({dimension: 'cube-array', format: 'eac-rg11unorm', baseMipLevel: 0, arrayLayerCount: 6});
try {
computePassEncoder7.setBindGroup(3, bindGroup16);
} catch {}
try {
computePassEncoder7.setBindGroup(0, bindGroup5, new Uint32Array(4120), 1_660, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer22);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
  await promise1;
} catch {}
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'smpte170m'} });
let commandEncoder37 = device0.createCommandEncoder();
try {
renderPassEncoder13.setVertexBuffer(2, buffer1, 0, 8);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 102, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture18,
  mipLevel: 3,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture58 = device0.createTexture({
  size: [64],
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder12 = commandEncoder26.beginComputePass();
try {
computePassEncoder12.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder10.beginOcclusionQuery(1461);
} catch {}
try {
renderPassEncoder10.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture57,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(18_756).fill(239), /* required buffer size: 18_756 */
{offset: 164, bytesPerRow: 166, rowsPerImage: 14}, {width: 42, height: 0, depthOrArrayLayers: 9});
} catch {}
let sampler4 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'mirror-repeat'});
try {
computePassEncoder12.setBindGroup(0, bindGroup16, new Uint32Array(1055), 198, 0);
} catch {}
try {
computePassEncoder7.end();
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer12, 0, 0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer17, 'uint32', 4, 8);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(6, buffer0, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer17, 0, new Float32Array(7815).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.375)), 395, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture43,
  mipLevel: 0,
  origin: {x: 648, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(61).fill(114), /* required buffer size: 61 */
{offset: 61}, {width: 76, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let commandEncoder38 = device0.createCommandEncoder();
let texture59 = device0.createTexture({
  size: {width: 45, height: 26, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView38 = texture3.createView({dimension: '2d', format: 'r32sint', baseArrayLayer: 1});
let computePassEncoder13 = commandEncoder34.beginComputePass();
let sampler5 = device0.createSampler({addressModeV: 'mirror-repeat', magFilter: 'nearest', mipmapFilter: 'nearest'});
let externalTexture4 = device0.importExternalTexture({source: videoFrame8});
try {
computePassEncoder6.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder8.draw(11, 0, 568_575_732);
} catch {}
try {
renderPassEncoder8.drawIndexed(25, 0, 24, 522_280_525);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer34, 24);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer11, 0, 3_408);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup17, [256]);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(2, buffer0);
} catch {}
let commandEncoder39 = device0.createCommandEncoder({});
let externalTexture5 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'});
try {
computePassEncoder11.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer10, 4);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, undefined, 423_252_229, 604_125_888);
} catch {}
try {
commandEncoder9.clearBuffer(buffer28, 4);
} catch {}
try {
adapter0.label = '\u216d\ub2b8\ua8df\u{1fee9}\u2e89\u{1fd2d}\u2946';
} catch {}
try {
computePassEncoder11.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer34, 64);
} catch {}
await gc();
let commandEncoder40 = device0.createCommandEncoder({});
let texture60 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 601},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder13.setBindGroup(1, bindGroup11);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup11, new Uint32Array(3504), 94, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer29, 20);
} catch {}
try {
  await buffer23.mapAsync(GPUMapMode.READ, 104, 12068);
} catch {}
try {
commandEncoder37.copyTextureToTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 76, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture56,
  mipLevel: 0,
  origin: {x: 3, y: 35, z: 0},
  aspect: 'all',
},
{width: 34, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder36.clearBuffer(buffer17, 20);
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 52, resource: {buffer: buffer11, offset: 768}}],
});
let buffer35 = device0.createBuffer({size: 300, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture61 = device0.createTexture({
  size: [744, 3, 15],
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler6 = device0.createSampler({
  label: '\u{1fb01}\u0150\u{1fb14}\u{1f74f}\uc3c3\u79a5\u9cdc',
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 85.33,
  maxAnisotropy: 1,
});
let externalTexture6 = device0.importExternalTexture({source: videoFrame1});
try {
renderPassEncoder8.drawIndirect(buffer34, 12);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup6, new Uint32Array(2974), 699, 0);
} catch {}
let commandEncoder41 = device0.createCommandEncoder();
try {
renderPassEncoder7.setBindGroup(1, bindGroup19);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup7, new Uint32Array(2541), 54, 0);
} catch {}
try {
renderPassEncoder8.draw(81, 0, 2_031_803_120);
} catch {}
try {
renderPassEncoder8.drawIndexed(114, 0, 25, -1_959_495_091);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup13, new Uint32Array(3622), 2_070, 0);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1328 */
  offset: 1328,
  rowsPerImage: 952,
  buffer: buffer2,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 96, y: 15, z: 0},
  aspect: 'all',
}, {width: 60, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer36 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder42 = device0.createCommandEncoder({});
let sampler7 = device0.createSampler({
  label: '\u56de\u9f7e\u011f\u{1fdd8}\u5c3d\u{1fec3}',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  lodMaxClamp: 87.75,
  compare: 'not-equal',
});
try {
computePassEncoder10.setBindGroup(3, bindGroup9);
} catch {}
try {
renderPassEncoder8.draw(374, 0, 51_485_188);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup15, new Uint32Array(499), 99, 0);
} catch {}
try {
commandEncoder9.clearBuffer(buffer32);
} catch {}
let imageData3 = new ImageData(8, 24);
let bindGroup21 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 0, resource: textureView1},
    {binding: 1, resource: externalTexture3},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer1, size: 56}},
    {binding: 2, resource: {buffer: buffer1}},
  ],
});
let buffer37 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let texture62 = device0.createTexture({
  size: [408, 1, 9],
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler8 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.53,
  maxAnisotropy: 8,
});
try {
renderPassEncoder8.drawIndexedIndirect(buffer18, 24);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer2, 0, 3_288);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer11, 'uint16', 902, 241);
} catch {}
let arrayBuffer0 = buffer23.getMappedRange(1136, 1352);
let bindGroup22 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 90, resource: textureView8},
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer34, size: 40}},
    {binding: 1, resource: externalTexture6},
    {binding: 3, resource: {buffer: buffer11}},
  ],
});
let textureView39 = texture54.createView({dimension: '2d', baseArrayLayer: 5});
try {
renderPassEncoder8.setBindGroup(1, bindGroup1, new Uint32Array(1313), 207, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer34, 60);
} catch {}
try {
renderBundleEncoder11.setBindGroup(0, bindGroup7, []);
} catch {}
let bindGroup23 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer10}},
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer22, offset: 0}},
    {binding: 1, resource: externalTexture6},
  ],
});
try {
computePassEncoder6.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup8, new Uint32Array(4837), 687, 0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(4, buffer30, 32, 3);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline7);
} catch {}
let texture63 = device0.createTexture({
  size: [586, 12, 16],
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder13.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup22, new Uint32Array(5020), 101, 0);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder12.setStencilReference(223);
} catch {}
try {
commandEncoder38.insertDebugMarker('\u0c0b');
} catch {}
try {
device0.queue.writeBuffer(buffer28, 160, new Uint32Array(24026).map((_, i) => i * 3), 974, 0);
} catch {}
let bindGroup24 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 2, resource: {buffer: buffer11, offset: 1024}}],
});
let textureView40 = texture41.createView({format: 'r32float', mipLevelCount: 1});
let texture64 = device0.createTexture({
  size: [293, 6, 1],
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup8);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline6);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 64, new DataView(new ArrayBuffer(28052)), 2873, 0);
} catch {}
await gc();
let imageData4 = new ImageData(4, 112);
let pipelineLayout3 = device0.createPipelineLayout({
  bindGroupLayouts: [autogeneratedBindGroupLayout1, veryExplicitBindGroupLayout3, recycledExplicitBindGroupLayout1, autogeneratedBindGroupLayout0],
});
let buffer38 = device0.createBuffer({
  size: 40,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let computePassEncoder14 = commandEncoder36.beginComputePass();
try {
renderPassEncoder10.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 2, 0, -1_909_793_103);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer29, 8);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer18, 4);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer0, 'uint16', 0, 2);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(7, buffer0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 1_284, new DataView(new Uint8Array(4158).map((_, i) => i).buffer), 1352, 92);
} catch {}
let bindGroup25 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: externalTexture6},
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer1, offset: 0}},
    {binding: 3, resource: {buffer: buffer34, offset: 0}},
    {binding: 90, resource: textureView8},
  ],
});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 983});
let texture65 = device0.createTexture({
  size: {width: 64},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
computePassEncoder14.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 2, 0, 639_611_882);
} catch {}
try {
device0.queue.writeBuffer(buffer28, 44, new Uint32Array(16767).map((_, i) => i * 9), 13, 0);
} catch {}
let bindGroup26 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 90, resource: textureView8},
    {binding: 1, resource: externalTexture6},
    {binding: 0, resource: textureView0},
    {binding: 3, resource: {buffer: buffer1, offset: 0}},
    {binding: 2, resource: {buffer: buffer10}},
  ],
});
let commandEncoder43 = device0.createCommandEncoder();
let textureView41 = texture50.createView({dimension: '2d-array'});
let computePassEncoder15 = commandEncoder41.beginComputePass();
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder1.drawIndirect(buffer21, 68);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup1);
} catch {}
let textureView42 = texture25.createView({dimension: '2d-array'});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer29, 116); };
} catch {}
try {
computePassEncoder15.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.draw(338, 1, 1_404_685_530);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, 557_567_100);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(6, buffer2, 0, 6_577);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup25, new Uint32Array(1351), 85, 0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer12, 0, 7);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder18.copyBufferToTexture({
  /* bytesInLastRow: 2416 widthInBlocks: 151 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 5616 */
  offset: 5616,
  bytesPerRow: 26880,
  buffer: buffer2,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 241, y: 1, z: 0},
  aspect: 'all',
}, {width: 151, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 72, y: 0, z: 15},
  aspect: 'all',
}, new Uint8Array(21_282).fill(116), /* required buffer size: 21_282 */
{offset: 283, bytesPerRow: 253, rowsPerImage: 1}, {width: 64, height: 0, depthOrArrayLayers: 84});
} catch {}
let buffer39 = device0.createBuffer({size: 648, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let commandEncoder44 = device0.createCommandEncoder({});
let textureView43 = texture14.createView({dimension: '2d'});
try {
renderPassEncoder9.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer13, 0, 1);
} catch {}
try {
buffer29.unmap();
} catch {}
let bindGroup27 = device0.createBindGroup({
  label: '\ue5fe\u0557\u6fec\u1b5f',
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 2, resource: {buffer: buffer28}}],
});
let commandEncoder45 = device0.createCommandEncoder();
let commandBuffer4 = commandEncoder24.finish();
let texture66 = device0.createTexture({
  size: [204, 1, 1],
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler9 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.26,
  maxAnisotropy: 10,
});
try {
renderPassEncoder4.setIndexBuffer(buffer17, 'uint16', 6, 19);
} catch {}
try {
renderBundleEncoder11.drawIndirect(buffer29, 160);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer11, 'uint16', 264, 1_034);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline6);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 0, new DataView(new ArrayBuffer(25516)), 1355, 0);
} catch {}
let textureView44 = texture22.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder8.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer18, 4);
} catch {}
try {
renderBundleEncoder11.draw(256, 0, 970_203_574);
} catch {}
try {
renderBundleEncoder11.drawIndexedIndirect(buffer21, 8);
} catch {}
let img1 = await imageWithData(1, 40, '#10101010', '#20202020');
let buffer40 = device0.createBuffer({size: 212, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture67 = device0.createTexture({
  size: [90, 52, 455],
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle0 = renderBundleEncoder11.finish({});
try {
renderPassEncoder1.draw(110, 1, 108_663_886);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer38, 4);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u0258');
} catch {}
try {
  await promise3;
} catch {}
let autogeneratedBindGroupLayout2 = pipeline1.getBindGroupLayout(0);
let bindGroup28 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 52, resource: {buffer: buffer11}}]});
let commandEncoder46 = device0.createCommandEncoder({});
let externalTexture7 = device0.importExternalTexture({source: videoFrame8});
try {
renderPassEncoder1.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder1.draw(31, 1, 1_203_400_882, 2);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, 627_058_008);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer29, 84);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline4);
} catch {}
let commandEncoder47 = device0.createCommandEncoder({});
let commandBuffer5 = commandEncoder20.finish();
let texture68 = device0.createTexture({size: [1488], dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_SRC});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer10, 0); };
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup23, new Uint32Array(7560), 3_811, 0);
} catch {}
try {
renderPassEncoder10.beginOcclusionQuery(503);
} catch {}
try {
renderPassEncoder1.draw(360, 1, 831_691_242);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, 168_066_522, 0);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(2, buffer22, 36);
} catch {}
try {
commandEncoder44.clearBuffer(buffer34, 8);
} catch {}
try {
renderBundleEncoder2.pushDebugGroup('\u1df6');
} catch {}
try {
device0.queue.submit([commandBuffer5]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 2, y: 1 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 57, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
try {
renderPassEncoder1.drawIndirect(buffer39, 236);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline7);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 408, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame1,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 1,
  origin: {x: 57, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
bindGroup7.label = '\u4838\u80b2\uf974\u04cf\u0489\u595c\u{1fe32}\u{1fdfb}\u{1fdf3}';
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

diagnostic(info, xyz);

struct FragmentInput3 {
  @location(10) @interpolate(perspective, centroid) location_10: f32,
  @location(4) location_4: i32,
  @location(9) @interpolate(perspective, first) location_9: vec4f,
}

struct FragmentOutput1 {
  @location(0) location_0: u32,
}

@group(1) @binding(2) var<storage, read_write> buffer43: array<array<array<f16, 3>, 2>>;

@group(0) @binding(90) var st12: texture_storage_2d<rgba16uint, write>;

struct VertexInput13 {
  @location(3) location_3: f32,
}

@id(43872) override override6: i32;

struct T0 {
  @size(64) f0: array<array<bool, 8>, 1>,
  @align(32) @size(1536) f1: vec2h,
  @size(320) f2: array<vec2f, 10>,
  @size(64) f3: array<vec4i, 1>,
  @align(16) @size(64) f4: vec2i,
  @size(320) f5: f16,
}

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

struct VertexInput9 {
  @location(1) @interpolate(flat, centroid) location_1: vec2i,
  @location(6) @interpolate(perspective, sample) location_6: f16,
}

var<workgroup> vw6: VertexOutput2;

struct VertexInput14 {
  @location(15) location_15: vec4u,
}

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

var<workgroup> vw5: FragmentInput5;

@group(1) @binding(3) var<storage, read> buffer44: array<array<array<array<array<array<f16, 1>, 7>, 1>, 2>, 2>>;

@group(0) @binding(0) var st11: texture_storage_3d<r32float, read_write>;

var<workgroup> vw4: vec2h;

@id(44587) override override3: f16;

@group(1) @binding(90) var st14: texture_storage_2d<rgba16uint, write>;

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

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

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

struct VertexInput11 {
  @location(12) location_12: vec2f,
  @builtin(vertex_index) vertex_index: u32,
  @location(8) location_8: f16,
  @location(10) location_10: f32,
  @location(7) @interpolate(flat) location_7: vec2u,
  @location(11) location_11: vec2u,
  @location(14) location_14: vec4u,
  @location(0) @interpolate(flat, sample) location_0: vec2u,
}

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

override override5: i32;

struct VertexOutput2 {
  @location(2) location_2: vec2i,
  @location(14) location_14: f16,
  @location(9) @interpolate(flat, either) location_9: f16,
  @location(0) @interpolate(perspective, sample) location_0: vec4h,
  @location(11) location_11: f16,
  @location(3) @interpolate(flat) location_3: vec2i,
  @location(10) @interpolate(perspective, center) location_10: f32,
  @location(15) @interpolate(perspective, sample) location_15: vec4f,
  @location(1) location_1: vec4i,
  @location(13) location_13: vec4f,
  @builtin(position) position: vec4f,
  @location(5) @interpolate(flat, first) location_5: u32,
  @location(7) location_7: vec4h,
}

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

struct VertexInput10 {
  @builtin(instance_index) instance_index: u32,
  @location(13) location_13: u32,
}

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

override override4: i32;

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

/* zero global variables used */
@vertex
fn vertex2(a0: VertexInput9, @location(5) @interpolate(flat, either) location_5: f16, @location(4) @interpolate(flat) location_4: vec4u, a3: VertexInput10, a4: VertexInput11, @location(2) location_2: f32, a6: VertexInput12, a7: VertexInput13, a8: VertexInput14) -> VertexOutput2 {
  var out: VertexOutput2;
  out.position = bitcast<vec4f>(out.location_3.rrgr.yzxx);
  out.location_11 = f16(a6.location_9[0]);
  var vf34: f32 = out.position[vec4u(out.location_1).r];
  let ptr14: ptr<function, vec4f> = &out.location_15;
  return out;
}

/* used global variables: st11, st12, st14 */
@fragment
fn fragment1(@location(1) @interpolate(linear) location_1: vec2h, a1: FragmentInput3, @builtin(sample_mask) sample_mask: u32, a3: FragmentInput4, a4: FragmentInput5, @builtin(sample_index) sample_index: u32) -> FragmentOutput1 {
  var out: FragmentOutput1;
  var vf35: vec3i = firstTrailingBit(vec3i(unconst_i32(468870281), unconst_i32(57686429), unconst_i32(244763454)));
  textureStore(st12, vec2i(unconst_i32(15589768), unconst_i32(498060214)), vec4u(vec4u(unconst_u32(72139715), unconst_u32(12296808), unconst_u32(713338322), unconst_u32(36533725))));
  var vf36: FragmentInput3 = a1;
  var vf37: FragmentInput3 = a1;
  textureStore(st14, vec2i(unconst_i32(296731423), unconst_i32(-74450742)), vec4u(vec4u(unconst_u32(372534877), unconst_u32(763767154), unconst_u32(489370251), unconst_u32(107871033))));
  vf35 = vec3i(bitcast<i32>(vf37.location_10));
  let vf38: vec2f = trunc(vec2f(asinh(unconst_f32(0.1243))));
  textureStore(st11, vec3i(unconst_i32(564080111), unconst_i32(-217983079), unconst_i32(401794317)), vec4f(vec4f(unconst_f32(0.3188e-42), unconst_f32(0.1329), unconst_f32(0.03587e22), unconst_f32(0.1204e25))));
  vf35 = firstTrailingBit(vec3i(i32(out.location_0)));
  return out;
  _ = st14;
  _ = st11;
  _ = st12;
}

/* used global variables: buffer41, buffer43, buffer44, st14 */
@compute @workgroup_size(3, 3, 1)
fn compute2() {
  buffer43[u32(buffer41[unconst_u32(325135259)][1][unconst_u32(150356413)][unconst_u32(13450935)][unconst_u32(189017767)][unconst_u32(698956424)][unconst_u32(491461416)][unconst_u32(787274762)])][unconst_u32(24621505)][unconst_u32(164017851)] = buffer41[arrayLength(&buffer41)][1][bitcast<vec2u>((*&vw6).location_3.rr)[0]][u32(buffer41[arrayLength(&buffer41)][1][unconst_u32(2976688239)][0][2][0][u32(buffer41[unconst_u32(126069329)][1][unconst_u32(4554657)][unconst_u32(56891121)][unconst_u32(1273457090)][unconst_u32(84153117)][unconst_u32(1038011286)][0])][0])][unconst_u32(1181501612)][0][0][0];
  while bool((*&buffer41)[unconst_u32(164982873)][1][unconst_u32(2350150637)][0][2][0][0][0]) {
  let ptr15: ptr<storage, f16, read_write> = &(*&buffer41)[unconst_u32(395224974)][unconst_u32(78305912)][unconst_u32(56088505)][0][2][0][0][unconst_u32(51080183)];
  vw5 = FragmentInput5(vec4f(f32((*&buffer41)[arrayLength(&(*&buffer41))][u32((*&buffer41)[arrayLength(&(*&buffer41))][unconst_u32(342564771)][unconst_u32(268289118)][0][2][unconst_u32(1035264268)][0][0])][0][0][unconst_u32(1319816077)][unconst_u32(610799499)][unconst_u32(1376816123)][0])));
  let ptr16: ptr<storage, array<f16, 1>, read_write> = &buffer41[arrayLength(&buffer41)][unconst_u32(1504150612)][0][0][unconst_u32(1675723928)][0][unconst_u32(107731926)];
  textureStore(st14, vec2i(unconst_i32(190811541), unconst_i32(381750542)), vec4u(vec4u(unconst_u32(441440569), unconst_u32(367840938), unconst_u32(43261816), unconst_u32(670044923))));
  let ptr17: ptr<storage, f16, read> = &(*&buffer44)[unconst_u32(661783121)][1][1][unconst_u32(178006755)][6][unconst_u32(380694321)];
  _ = st14;
  _ = buffer44;
  _ = buffer41;
}
  vw4 = vec2h(buffer41[unconst_u32(318458318)][unconst_u32(432374299)][unconst_u32(1243294869)][0][2][unconst_u32(660390593)][0][unconst_u32(1307883394)]);
  textureStore(st14, vec2i(unconst_i32(470737770), unconst_i32(787662108)), vec4u(vec4u(unconst_u32(444865439), unconst_u32(87420165), unconst_u32(414752396), unconst_u32(1760587305))));
  let ptr18: ptr<storage, array<f16, 1>, read> = &buffer44[unconst_u32(375424783)][1][1][0][unconst_u32(1324319554)];
  let ptr19: ptr<storage, f16, read_write> = &(*&buffer41)[arrayLength(&(*&buffer41))][u32(buffer41[unconst_u32(622118579)][1][unconst_u32(258087576)][unconst_u32(611816023)][unconst_u32(498152488)][0][0][0])][0][0][2][0][u32((*&buffer41)[unconst_u32(379802798)][unconst_u32(501099643)][0][unconst_u32(647618543)][2][unconst_u32(597772837)][0][0])][unconst_u32(946318290)];
  buffer41[unconst_u32(130121421)][unconst_u32(2886993934)][u32(buffer41[unconst_u32(867264834)][unconst_u32(1445937219)][0][0][2][0][0][0])][unconst_u32(857191622)][unconst_u32(862521693)][0][unconst_u32(467037148)][unconst_u32(53088290)] = buffer44[unconst_u32(884841833)][1][1][unconst_u32(139234275)][6][0];
  _ = buffer41;
  _ = st14;
  _ = buffer44;
  _ = buffer43;
}`,
});
let bindGroup29 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 2, resource: {buffer: buffer38}},
    {binding: 90, resource: textureView43},
    {binding: 1, resource: externalTexture1},
    {binding: 0, resource: textureView0},
    {binding: 3, resource: {buffer: buffer1}},
  ],
});
let computePassEncoder16 = commandEncoder27.beginComputePass();
let renderPassEncoder14 = commandEncoder21.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: 474.6, g: 523.3, b: 964.2, a: 498.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 66514671,
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup14, new Uint32Array(356), 28, 0);
} catch {}
try {
renderPassEncoder1.draw(99, 1, 251_964_500);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, 445_818_996);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer38, 4);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer0, 0, 1);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup6, new Uint32Array(2645), 6, 0);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline6);
} catch {}
let buffer45 = device0.createBuffer({size: 340, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder49 = device0.createCommandEncoder({});
let textureView45 = texture55.createView({baseMipLevel: 0});
let texture69 = device0.createTexture({
  size: [1488, 6, 5],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView46 = texture18.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder8.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder1.draw(274, 1, 232_184_257);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer34, 4);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer38, 20);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
commandEncoder9.resolveQuerySet(querySet1, 119, 133, buffer11, 0);
} catch {}
await gc();
let recycledExplicitBindGroupLayout2 = pipeline0.getBindGroupLayout(1);
let bindGroup30 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 2, resource: {buffer: buffer22}},
    {binding: 0, resource: textureView1},
    {binding: 3, resource: {buffer: buffer1, size: 60}},
    {binding: 1, resource: externalTexture3},
    {binding: 90, resource: textureView43},
  ],
});
let buffer46 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture70 = device0.createTexture({
  size: {width: 744, height: 3, depthOrArrayLayers: 26},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder7.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder1.draw(54, 1, 593_925_876);
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

enable f16;

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

struct T13 {
  @size(16) f0: vec2u,
  @size(50) f1: T5,
}

struct T10 {
  f0: T8,
}

@group(0) @binding(2) var<storage, read_write> buffer47: T9;

struct T3 {
  @align(4) f0: T2,
}

struct T4 {
  @size(56) f0: atomic<u32>,
}

@group(0) @binding(0) var st15: texture_storage_3d<r32float, read_write>;

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

@group(1) @binding(3) var<storage, read> buffer50: array<T6>;

struct FragmentInput8 {
  @location(7) location_7: vec4h,
  @location(13) location_13: vec4f,
}

struct FragmentInput7 {
  @location(0) @interpolate(perspective, sample) location_0: vec4h,
  @location(15) @interpolate(perspective, sample) location_15: vec4f,
  @location(5) @interpolate(flat, first) location_5: u32,
  @location(9) @interpolate(flat, either) location_9: f16,
  @location(10) @interpolate(perspective, center) location_10: f32,
  @location(14) location_14: f16,
}

struct T2 {
  f0: array<f16>,
}

struct T15 {
  f0: T7,
}

struct T11 {
  f0: array<u32>,
}

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

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

@group(0) @binding(3) var<storage, read> buffer48: array<T6>;

@group(1) @binding(2) var<storage, read_write> buffer49: T9;

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

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

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

struct T12 {
  f0: T3,
}

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

struct FragmentOutput2 {
  @location(0) location_0: u32,
}

@id(28932) override override7 = true;

struct T7 {
  f0: array<u32>,
}

@group(0) @binding(90) var st16: texture_storage_2d<rgba16uint, write>;

struct T9 {
  @size(12) f0: atomic<u32>,
}

struct T14 {
  f0: array<T1, 1>,
}

struct T5 {
  @size(12) f0: vec2u,
}

@group(1) @binding(0) var st17: texture_storage_3d<r32float, read_write>;

struct T0 {
  @size(56) f0: u32,
}

struct FragmentInput6 {
  @location(1) location_1: vec4i,
  @location(2) location_2: vec2i,
  @location(3) @interpolate(flat) location_3: vec2i,
}

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

struct T6 {
  @size(56) f0: T5,
}

@id(59276) override override8: f16;

/* used global variables: st15, st16, st17 */
@fragment
fn fragment2(a0: FragmentInput6, a1: FragmentInput7, @location(11) location_11: f16, a3: FragmentInput8, @builtin(sample_index) sample_index: u32, a5: FragmentInput9, @builtin(position) position: vec4f, @builtin(front_facing) front_facing: bool) -> FragmentOutput2 {
  var out: FragmentOutput2;
  {
  textureStore(st15, vec3i(unconst_i32(588738628), unconst_i32(253271495), unconst_i32(13026218)), vec4f(vec4f(unconst_f32(0.02727e-44), unconst_f32(0.1142e-36), unconst_f32(0.2433), unconst_f32(0.06667e-45))));
  textureStore(st17, vec3i(unconst_i32(163199764), unconst_i32(-400211110), unconst_i32(443099329)), vec4f(vec4f(unconst_f32(0.2130), unconst_f32(0.03941), unconst_f32(0.2495), unconst_f32(0.00895e-40))));
  _ = st17;
  _ = st15;
}
  let vf39: f16 = smoothstep(unconst_f16(17954.3), unconst_f16(-9511.2), unconst_f16(4659.2));
  textureStore(st16, vec2i(unconst_i32(192071225), unconst_i32(1501456224)), vec4u(vec4u(unconst_u32(264999053), unconst_u32(1129235335), unconst_u32(1655800563), unconst_u32(269131358))));
  let vf40: u32 = pack4xI8(vec4i(unconst_i32(971382265), unconst_i32(52186961), unconst_i32(89175562), unconst_i32(522836275)));
  var vf41: u32 = pack4xU8Clamp(vec4u(a3.location_13.aaaa.gbbr.rrga.wwwx.zzzy));
  out.location_0 = out.location_0;
  textureStore(st16, vec2i(unconst_i32(15620167), unconst_i32(72041538)), vec4u(vec4u(unconst_u32(423017708), unconst_u32(415277111), unconst_u32(460458090), unconst_u32(675094254))));
  vf41 = pack4xI8(a0.location_1);
  textureStore(st16, vec2i(unconst_i32(278872266), unconst_i32(673960541)), vec4u(vec4u(unconst_u32(625026474), unconst_u32(65905027), unconst_u32(897289990), unconst_u32(357508461))));
  out.location_0 = u32(override8);
  return out;
  _ = override8;
  _ = st15;
  _ = st17;
  _ = st16;
}

/* zero global variables used */
@fragment
fn fragment3() -> FragmentOutput3 {
  var out: FragmentOutput3;
  let vf42: vec2f = floor(vec2f(unconst_f32(0.01779e2), unconst_f32(0.03326)));
  return out;
}

/* used global variables: buffer47, buffer48, buffer49, buffer50, st16 */
@compute @workgroup_size(5, 1, 1)
fn compute3() {
  _ = st16;
  var vf43: u32 = buffer48[arrayLength(&buffer48)].f0.f0[u32( ~vec3i(unconst_i32(629424937), unconst_i32(664182999), unconst_i32(35204535)).r)];
  atomicAnd(&buffer49.f0, unconst_u32(150646147));
  atomicCompareExchangeWeak(&buffer47.f0, unconst_u32(711931854), unconst_u32(136421865));
  let ptr20: ptr<storage, T6, read> = &(*&buffer50)[unconst_i32(-106797792)];
  let ptr21: ptr<storage, vec2u, read> = &buffer48[arrayLength(&buffer48)].f0.f0;
  atomicExchange(&buffer47.f0, unconst_u32(703971795));
  _ = buffer49;
  _ = buffer48;
  _ = buffer47;
  _ = st16;
  _ = buffer50;
}`,
});
let commandEncoder50 = device0.createCommandEncoder({});
let computePassEncoder17 = commandEncoder37.beginComputePass();
let renderPassEncoder15 = commandEncoder14.beginRenderPass({
  colorAttachments: [{
  view: textureView34,
  depthSlice: 14,
  clearValue: { r: -234.4, g: 484.6, b: 85.35, a: -106.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder15.setBindGroup(2, bindGroup0);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer40, 0);
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 255, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(1); };
} catch {}
let bindGroup31 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 0, resource: textureView1},
    {binding: 1, resource: externalTexture1},
    {binding: 2, resource: {buffer: buffer34}},
    {binding: 3, resource: {buffer: buffer22}},
    {binding: 90, resource: textureView43},
  ],
});
let commandEncoder51 = device0.createCommandEncoder();
let textureView47 = texture45.createView({label: '\u7077\u0102\u729d\u07f6\u0091'});
let computePassEncoder18 = commandEncoder49.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer21, 4); };
} catch {}
try {
computePassEncoder16.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer32, 'uint16', 6, 5);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup5, new Uint32Array(2664), 284, 0);
} catch {}
try {
renderBundleEncoder1.draw(121, 1, 1_053_836_280);
} catch {}
try {
renderBundleEncoder1.drawIndexed(2, 1, 0, 282_102_762);
} catch {}
try {
commandEncoder30.copyBufferToBuffer(buffer36, 20, buffer34, 36, 0);
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {
  fullRange: true,
  matrix: 'unspecified',
  primaries: 'smpteSt4281',
  transfer: 'bt1361ExtendedColourGamut',
} });
let bindGroup32 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 3, resource: {buffer: buffer10}},
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer1}},
    {binding: 1, resource: externalTexture7},
    {binding: 0, resource: textureView0},
  ],
});
let textureView48 = texture35.createView({aspect: 'depth-only', baseMipLevel: 0});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: false});
let sampler10 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  lodMaxClamp: 97.70,
  compare: 'never',
});
try {
computePassEncoder18.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder10.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.draw(52, 1, 309_303_037);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer34, 32);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup9, new Uint32Array(284), 53, 0);
} catch {}
let arrayBuffer1 = buffer23.getMappedRange(104, 84);
let promise4 = device0.queue.onSubmittedWorkDone();
await gc();
let commandEncoder52 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer18, 16); };
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup25);
} catch {}
try {
renderPassEncoder2.drawIndexed(0, 0, 0, 655_958_401);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer18, 4);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline4);
} catch {}
try {
commandEncoder45.resolveQuerySet(querySet0, 53, 0, buffer19, 0);
} catch {}
let buffer51 = device0.createBuffer({size: 164, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView49 = texture9.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundle1 = renderBundleEncoder1.finish();
try {
renderPassEncoder14.setBindGroup(1, bindGroup31);
} catch {}
try {
renderPassEncoder2.draw(137, 0, 267_133_111);
} catch {}
try {
renderPassEncoder2.drawIndexed(0, 0, 0, 445_529_769);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer29, 8);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(26); };
} catch {}
let texture71 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView50 = texture16.createView({dimension: '2d-array', mipLevelCount: 1});
let renderPassEncoder16 = commandEncoder32.beginRenderPass({
  colorAttachments: [{
  view: textureView47,
  depthSlice: 1,
  clearValue: { r: -460.7, g: -678.4, b: 879.5, a: 183.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder9.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder1.draw(70, 1, 429_013_089);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer34, 12);
} catch {}
try {
  await buffer46.mapAsync(GPUMapMode.WRITE);
} catch {}
try {
renderBundleEncoder2.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer38, 0, new DataView(new ArrayBuffer(32691)), 7539, 0);
} catch {}
let buffer52 = device0.createBuffer({size: 44, usage: GPUBufferUsage.UNIFORM});
let textureView51 = texture0.createView({format: 'r32float'});
try {
renderPassEncoder2.draw(238, 0, 490_661_398);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer40, 52);
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1160 */
  offset: 1160,
  bytesPerRow: 0,
  buffer: buffer2,
}, {
  texture: texture2,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder50.copyTextureToBuffer({
  texture: texture29,
  mipLevel: 1,
  origin: {x: 160, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1880 widthInBlocks: 235 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 176 */
  offset: 176,
  rowsPerImage: 89,
  buffer: buffer28,
}, {width: 940, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap0 = await createImageBitmap(videoFrame3);
let commandEncoder53 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer29, 56); };
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup5, new Uint32Array(768), 22, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(4, buffer30, 0, 7);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup33 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 2, resource: {buffer: buffer28}}]});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(2, 1, 2); };
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer34, 64);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer9);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup31);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(6, buffer2, 5_576);
} catch {}
let imageData5 = new ImageData(12, 4);
let bindGroup34 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 90, resource: textureView43},
    {binding: 2, resource: {buffer: buffer34}},
    {binding: 1, resource: externalTexture6},
    {binding: 0, resource: textureView1},
    {binding: 3, resource: {buffer: buffer28}},
  ],
});
let commandEncoder54 = device0.createCommandEncoder({});
let textureView52 = texture32.createView({dimension: '2d-array'});
try {
renderPassEncoder2.setBindGroup(1, bindGroup32);
} catch {}
try {
renderPassEncoder1.draw(57, 1, 828_678_057, 1);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline7);
} catch {}
let commandEncoder55 = device0.createCommandEncoder({});
try {
renderPassEncoder1.draw(142, 1, 878_196_178);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer38, 20);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer29, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer32, 'uint16', 14, 17);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup15, new Uint32Array(3404), 439, 0);
} catch {}
let texture72 = device0.createTexture({
  size: {width: 586},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
renderPassEncoder13.setBindGroup(2, bindGroup18, [0]);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup13, new Uint32Array(1968), 96, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer17, 'uint32', 0, 16);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup31);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(7, buffer0);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 32, new Uint32Array(1988).map((_, i) => i * 5), 20, 12);
} catch {}
let pipeline9 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment2',
  constants: {59_276: 1},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex2',
    buffers: [
      {
        arrayStride: 52,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 4, shaderLocation: 2},
          {format: 'uint16x2', offset: 4, shaderLocation: 11},
          {format: 'unorm16x2', offset: 24, shaderLocation: 6},
          {format: 'uint16x4', offset: 0, shaderLocation: 4},
          {format: 'float32x3', offset: 0, shaderLocation: 3},
          {format: 'sint32x4', offset: 4, shaderLocation: 9},
          {format: 'sint32', offset: 0, shaderLocation: 1},
          {format: 'uint32x2', offset: 0, shaderLocation: 15},
          {format: 'uint32', offset: 4, shaderLocation: 7},
          {format: 'uint8x4', offset: 12, shaderLocation: 0},
          {format: 'float32x3', offset: 0, shaderLocation: 10},
          {format: 'snorm8x4', offset: 4, shaderLocation: 5},
          {format: 'float16x2', offset: 16, shaderLocation: 12},
          {format: 'snorm8x2', offset: 4, shaderLocation: 8},
          {format: 'uint8x2', offset: 8, shaderLocation: 13},
        ],
      },
      {arrayStride: 16, attributes: [{format: 'uint16x2', offset: 0, shaderLocation: 14}]},
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true},
});
let textureView53 = texture44.createView({dimension: '2d-array'});
let textureView54 = texture64.createView({format: 'r16uint', mipLevelCount: 1});
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 2, 0, 8_512_288);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer34, 12);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer34, 20);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer13, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 12, new DataView(new ArrayBuffer(16250)), 1199, 16);
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte432', transfer: 'smpteSt4281'} });
let bindGroup35 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 52, resource: {buffer: buffer22}}]});
let texture73 = device0.createTexture({
  size: {width: 293, height: 6, depthOrArrayLayers: 34},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture8 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer18, 32); };
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer29, 4);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer39, 88);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer28, 'uint16', 6, 226);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer22, 0, 44);
} catch {}
try {
commandEncoder52.copyBufferToBuffer(buffer10, 4, buffer17, 12, 16);
} catch {}
let buffer53 = device0.createBuffer({size: 240, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder4.setBindGroup(2, bindGroup11, new Uint32Array(1139), 8, 0);
} catch {}
try {
renderPassEncoder2.drawIndexed(0, 0, 0, 979_925_668);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer29, 56);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 12, new Float32Array(1118).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.046)), 326, 20);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 408, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 1,
  origin: {x: 118, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer54 = device0.createBuffer({size: 96, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let commandEncoder56 = device0.createCommandEncoder({});
try {
renderPassEncoder1.setBindGroup(1, bindGroup26, new Uint32Array(2081), 5, 0);
} catch {}
try {
renderPassEncoder14.draw(83, 0, 291_140_453);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline6);
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
let texture74 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 20},
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder19 = commandEncoder35.beginComputePass();
let renderPassEncoder17 = commandEncoder57.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  depthSlice: 37,
  clearValue: { r: 367.0, g: 732.2, b: -433.2, a: 915.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder18.setBindGroup(1, bindGroup25);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder14.draw(132, 0, 1_066_620_390);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer17, 'uint32', 36, 1);
} catch {}
let computePassEncoder20 = commandEncoder44.beginComputePass();
try {
renderPassEncoder2.drawIndexedIndirect(buffer40, 8);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer34, 36);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 105, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture56,
  mipLevel: 0,
  origin: {x: 77, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer55 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder58 = device0.createCommandEncoder({});
let textureView55 = texture25.createView({format: 'astc-8x6-unorm', arrayLayerCount: 1});
let computePassEncoder21 = commandEncoder52.beginComputePass();
let renderPassEncoder18 = commandEncoder33.beginRenderPass({
  colorAttachments: [{
  view: textureView54,
  clearValue: { r: -849.7, g: -872.3, b: -189.3, a: 964.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder13.setBindGroup(0, bindGroup4);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer10, 0); };
} catch {}
try {
computePassEncoder20.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, 1_318_646_762);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer2, 0);
} catch {}
try {
commandEncoder40.copyTextureToTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 148, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture11,
  mipLevel: 2,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup36 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer54}},
    {binding: 90, resource: textureView43},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 1, resource: externalTexture3},
  ],
});
let texture75 = device0.createTexture({size: {width: 90}, dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_DST});
let textureView56 = texture47.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(2, 1, 2); };
} catch {}
try {
computePassEncoder13.end();
} catch {}
try {
computePassEncoder21.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.draw(60, 1, 112_653_657);
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, -1_961_768_990);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer18, 4);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer34, 48);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer12, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 0, new DataView(new ArrayBuffer(524)), 0, 0);
} catch {}
let texture76 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 265},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder2.drawIndexed(0, 0, 0, 5_717_522, 0);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer18, 16);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 408, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 2, y: 36 },
  flipY: false,
}, {
  texture: texture18,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout3 = pipeline5.getBindGroupLayout(0);
let bindGroup37 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 52, resource: {buffer: buffer54, size: 52}}],
});
let commandEncoder59 = device0.createCommandEncoder({});
try {
renderPassEncoder1.drawIndexed(2, 1, 0, -1_922_740_581);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer18, 8);
} catch {}
try {
renderBundleEncoder18.setBindGroup(2, bindGroup17, [256]);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
try {
buffer30.label = '\u0209\u{1f646}\u03d7\u0039\ubfb4\u06a4\ubaeb\u{1f668}\uf24b\u0519\u0549';
} catch {}
let bindGroup38 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 1, resource: externalTexture5},
    {binding: 3, resource: {buffer: buffer22}},
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer1}},
    {binding: 0, resource: textureView1},
  ],
});
let commandBuffer6 = commandEncoder34.finish();
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer40, 28); };
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, 258_518_608);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer21, 0);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer34, 40);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer0);
} catch {}
let imageData6 = new ImageData(4, 100);
let bindGroup39 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 52, resource: {buffer: buffer22}}]});
let computePassEncoder22 = commandEncoder53.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer34, 4); };
} catch {}
try {
computePassEncoder22.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer40, 8);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer10, 4);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer28, 'uint16', 38, 15);
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(63); };
} catch {}
document.body.prepend(img1);
let offscreenCanvas0 = new OffscreenCanvas(419, 65);
let buffer56 = device0.createBuffer({size: 247, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let texture77 = device0.createTexture({
  size: [204, 1, 5],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView57 = texture14.createView({baseArrayLayer: 0});
try {
computePassEncoder20.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup32);
} catch {}
try {
renderPassEncoder2.drawIndexed(0, 0, 0, 270_453_408);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, buffer1);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 568, new Float32Array(2821).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9929)), 56, 260);
} catch {}
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
document.body.prepend(img0);
let texture78 = device0.createTexture({
  size: [102],
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder20.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer40, 4);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer28, 'uint32', 0, 97);
} catch {}
let pipeline10 = await device0.createRenderPipelineAsync({
  label: '\u04f3\u992d\u7aa0\ue83a\uf581\u9c41\u{1f7ab}',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment2',
  constants: {59_276: 1},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 0, shaderLocation: 0},
          {format: 'unorm16x2', offset: 0, shaderLocation: 8},
          {format: 'unorm8x2', offset: 6, shaderLocation: 6},
          {format: 'float32x4', offset: 0, shaderLocation: 2},
          {format: 'sint32', offset: 8, shaderLocation: 1},
          {format: 'uint16x2', offset: 8, shaderLocation: 15},
          {format: 'uint8x2', offset: 2, shaderLocation: 13},
          {format: 'uint32x4', offset: 0, shaderLocation: 7},
          {format: 'unorm8x4', offset: 4, shaderLocation: 10},
          {format: 'uint32x2', offset: 28, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 12},
          {format: 'snorm8x2', offset: 2, shaderLocation: 5},
          {format: 'uint16x2', offset: 4, shaderLocation: 4},
          {format: 'uint16x2', offset: 0, shaderLocation: 14},
          {format: 'sint16x4', offset: 4, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x4', offset: 0, shaderLocation: 3}],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
let texture79 = device0.createTexture({
  size: [2345, 48, 1],
  dimension: '2d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder14.setBindGroup(0, bindGroup6, new Uint32Array(799), 532, 0);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer40, 20);
} catch {}
await gc();
let texture80 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 3},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture81 = device0.createTexture({size: [816], sampleCount: 1, dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView58 = texture76.createView({format: 'r16uint', mipLevelCount: 1});
try {
computePassEncoder14.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder14.draw(239, 0, 1_187_967_562);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer29, 20);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(2, buffer0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder42.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 2,
  origin: {x: 0, y: 5, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3088 */
  offset: 3088,
  bytesPerRow: 36352,
  buffer: buffer11,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder42.clearBuffer(buffer45);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let buffer57 = device0.createBuffer({size: 540, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let texture82 = device0.createTexture({
  size: {width: 204, height: 1, depthOrArrayLayers: 7},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder19 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: 572.5, g: 184.4, b: 767.5, a: -728.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 161133575,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup15);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer21, 16); };
} catch {}
try {
renderPassEncoder1.drawIndexed(2, 1, 0, -2_007_051_322);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer32, 'uint32', 16, 24);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer30);
} catch {}
try {
device0.queue.writeBuffer(buffer28, 16, new Float32Array(20121).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.3322)), 1095, 0);
} catch {}
try {
adapter0.label = '\u17cd\ufa76\u{1f767}\u57ee\u5d7b\u{1f740}\u03bd\u0d65\u7d33\u0a8a';
} catch {}
let bindGroup40 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: externalTexture0},
    {binding: 2, resource: {buffer: buffer38}},
    {binding: 3, resource: {buffer: buffer1, offset: 0}},
    {binding: 90, resource: textureView43},
    {binding: 0, resource: textureView51},
  ],
});
let commandEncoder60 = device0.createCommandEncoder({});
let texture83 = device0.createTexture({
  size: {width: 2976},
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture84 = device0.createTexture({
  size: [1172, 24, 120],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView59 = texture73.createView({mipLevelCount: 2});
let computePassEncoder23 = commandEncoder56.beginComputePass();
try {
computePassEncoder23.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.draw(423, 1, 1_440_488_649);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(0, buffer9, 368, 90);
} catch {}
try {
renderBundleEncoder14.insertDebugMarker('\u1949');
} catch {}
let imageData7 = new ImageData(32, 12);
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
    {binding: 1, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 90,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let buffer58 = device0.createBuffer({size: 348, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder61 = device0.createCommandEncoder({});
let texture85 = device0.createTexture({
  size: {width: 586, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture86 = device0.createTexture({
  size: {width: 816, height: 1, depthOrArrayLayers: 24},
  mipLevelCount: 4,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup5, new Uint32Array(1878), 110, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder2.end();
} catch {}
try {
renderPassEncoder10.setStencilReference(344);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer21, 4);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(1, buffer51, 24, 56);
} catch {}
let recycledExplicitBindGroupLayout3 = pipeline2.getBindGroupLayout(1);
let textureView60 = texture82.createView({dimension: '2d', baseArrayLayer: 2});
let renderPassEncoder20 = commandEncoder50.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  clearValue: { r: 671.2, g: 952.5, b: -62.32, a: 89.20, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder12.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, buffer56);
} catch {}
let buffer59 = device0.createBuffer({size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder62 = device0.createCommandEncoder({});
let textureView61 = texture77.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder23.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.end();
} catch {}
try {
renderPassEncoder14.draw(35, 0, 287_818_045);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer29, 12);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(4, buffer9, 32);
} catch {}
let commandEncoder63 = device0.createCommandEncoder({});
let texture87 = device0.createTexture({
  size: [1488],
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler11 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 45.23,
  maxAnisotropy: 18,
});
try {
computePassEncoder22.setBindGroup(2, bindGroup6, new Uint32Array(1380), 764, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer10, 0); };
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer17, 'uint32', 16, 17);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup6);
} catch {}
try {
device0.queue.writeBuffer(buffer17, 32, new Uint32Array(22172).map((_, i) => i * 9), 4009, 0);
} catch {}
let textureView62 = texture78.createView({baseMipLevel: 0});
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder11.end();
} catch {}
try {
renderPassEncoder18.setStencilReference(464);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer17, 'uint32', 36, 35);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer0, 'uint16', 0, 2);
} catch {}
try {
commandEncoder9.copyBufferToTexture({
  /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2380 */
  offset: 2380,
  bytesPerRow: 15616,
  buffer: buffer2,
}, {
  texture: texture48,
  mipLevel: 1,
  origin: {x: 33, y: 4, z: 0},
  aspect: 'all',
}, {width: 13, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u3351');
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer60 = device0.createBuffer({size: 108, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder64 = device0.createCommandEncoder({});
let textureView63 = texture87.createView({});
let sampler12 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.41,
  compare: 'less',
  maxAnisotropy: 18,
});
try {
computePassEncoder20.setBindGroup(1, bindGroup4);
} catch {}
try {
computePassEncoder19.setBindGroup(2, bindGroup13, new Uint32Array(1886), 733, 0);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer21, 0);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(4, buffer22, 12, 25);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 4, new DataView(new ArrayBuffer(51852)), 6823, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 3, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture88 = device0.createTexture({
  size: [360, 210, 1],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView64 = texture86.createView({aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1});
let externalTexture9 = device0.importExternalTexture({source: videoFrame0});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 30, y: 3 },
  flipY: false,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 8, height: 3, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 2, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {binding: 8, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 11, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {binding: 15, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 29,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 52,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 139,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 146,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
    {
      binding: 238,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 239,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 252,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 303,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 337,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 571,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let buffer61 = device0.createBuffer({size: 452, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let textureView65 = texture79.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder24 = commandEncoder61.beginComputePass();
try {
renderPassEncoder14.drawIndirect(buffer38, 8);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer11, 'uint16', 154, 1_323);
} catch {}
let buffer62 = device0.createBuffer({size: 185, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
try {
computePassEncoder24.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer30, 0, 105);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup38, new Uint32Array(2028), 270, 0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 4, y: 4, z: 3},
  aspect: 'all',
}, new Uint8Array(11_516).fill(132), /* required buffer size: 11_516 */
{offset: 113, bytesPerRow: 59, rowsPerImage: 48}, {width: 4, height: 8, depthOrArrayLayers: 5});
} catch {}
let textureView66 = texture32.createView({dimension: '2d-array'});
try {
renderPassEncoder9.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup40, new Uint32Array(2225), 117, 0);
} catch {}
try {
commandEncoder46.resolveQuerySet(querySet1, 229, 6, buffer14, 0);
} catch {}
let pipeline11 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(29); };
} catch {}
let bindGroup41 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 2, resource: {buffer: buffer38}}]});
let buffer63 = device0.createBuffer({size: 232, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder65 = device0.createCommandEncoder();
let textureView67 = texture35.createView({label: '\u92c1\uc222\u07a3\u44fc\uadd8\u06c2\u0c00', aspect: 'depth-only', mipLevelCount: 1});
let sampler13 = device0.createSampler({addressModeV: 'repeat', magFilter: 'nearest'});
try {
computePassEncoder12.setBindGroup(0, bindGroup39, new Uint32Array(4447), 102, 1);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder14.draw(178, 0, 34_880_459);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 964, new BigInt64Array(3149).map((_, i) => BigInt(i - 5)), 108, 24);
} catch {}
let autogeneratedBindGroupLayout4 = pipeline3.getBindGroupLayout(0);
let texture89 = device0.createTexture({
  size: {width: 180, height: 105, depthOrArrayLayers: 70},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture90 = device0.createTexture({
  size: {width: 293, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  sampleCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler14 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.65,
});
try {
renderBundleEncoder10.setBindGroup(1, bindGroup15, new Uint32Array(136), 13, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 0, new Float32Array(624).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.297)), 8, 0);
} catch {}
let bindGroup42 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 407, resource: {buffer: buffer62, size: 44}},
    {binding: 5, resource: textureView16},
    {binding: 11, resource: textureView35},
    {binding: 8, resource: {buffer: buffer11}},
    {binding: 0, resource: {buffer: buffer34}},
    {binding: 3, resource: textureView26},
  ],
});
let computePassEncoder25 = commandEncoder39.beginComputePass();
try {
computePassEncoder25.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder14.end();
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup11);
} catch {}
try {
commandEncoder9.copyBufferToTexture({
  /* bytesInLastRow: 46 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 24 */
  offset: 24,
  buffer: buffer2,
}, {
  texture: texture70,
  mipLevel: 3,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder51.resolveQuerySet(querySet1, 38, 0, buffer22, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2345, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 157, y: 20, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData8 = new ImageData(4, 56);
let texture91 = device0.createTexture({
  size: {width: 293, height: 6, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView68 = texture58.createView({dimension: '1d'});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await promise4;
} catch {}
let buffer64 = device0.createBuffer({size: 780, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView69 = texture30.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let textureView70 = texture24.createView({dimension: '2d', mipLevelCount: 1});
try {
device0.pushErrorScope('validation');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let bindGroup43 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 2, resource: {buffer: buffer1}}]});
let computePassEncoder26 = commandEncoder46.beginComputePass();
try {
computePassEncoder26.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup14, []);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup23, new Uint32Array(1472), 178, 0);
} catch {}
try {
renderBundleEncoder10.setBindGroup(0, bindGroup25, new Uint32Array(1075), 106, 0);
} catch {}
try {
commandEncoder2.resolveQuerySet(querySet0, 103, 0, buffer19, 0);
} catch {}
document.body.prepend(img0);
let commandBuffer7 = commandEncoder25.finish();
try {
renderPassEncoder16.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup27, new Uint32Array(155), 10, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline10);
} catch {}
try {
  await promise5;
} catch {}
try {
autogeneratedBindGroupLayout4.label = '\u7dc3\u0667\u0098';
} catch {}
let texture92 = device0.createTexture({size: [1488, 6, 1], format: 'r16uint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], sampleCount: 1, depthReadOnly: true});
try {
computePassEncoder12.setBindGroup(1, bindGroup18, [0]);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup14);
} catch {}
try {
  await buffer53.mapAsync(GPUMapMode.READ, 32);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {binding: 52, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
  ],
});
try {
renderBundleEncoder18.setIndexBuffer(buffer0, 'uint16', 0, 0);
} catch {}
try {
commandEncoder63.copyBufferToBuffer(buffer36, 8, buffer39, 16, 8);
} catch {}
try {
commandEncoder23.copyTextureToTexture({
  texture: texture18,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 1,
  origin: {x: 69, y: 0, z: 0},
  aspect: 'all',
},
{width: 41, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderPassEncoder21 = commandEncoder58.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  depthSlice: 28,
  clearValue: { r: 990.8, g: -972.7, b: -190.3, a: 588.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 37837943,
});
try {
renderPassEncoder3.setBindGroup(1, bindGroup36);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer1, 0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup23, new Uint32Array(681), 38, 0);
} catch {}
try {
commandEncoder18.copyTextureToTexture({
  texture: texture19,
  mipLevel: 1,
  origin: {x: 116, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture66,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
},
{width: 83, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder66 = device0.createCommandEncoder({});
let sampler15 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 71.42,
  maxAnisotropy: 15,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup23, new Uint32Array(1207), 45, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture93 = device0.createTexture({
  size: {width: 90, height: 52, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder10.setBindGroup(0, bindGroup31);
} catch {}
try {
renderBundleEncoder22.setBindGroup(1, bindGroup25, new Uint32Array(2248), 99, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer17, 'uint32', 0, 0);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
commandEncoder43.copyBufferToTexture({
  /* bytesInLastRow: 216 widthInBlocks: 108 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1128 */
  offset: 1128,
  buffer: buffer2,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 59, y: 0, z: 0},
  aspect: 'all',
}, {width: 108, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer57, 92, new Uint32Array(8898).map((_, i) => i * 8), 1295, 24);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture43,
  mipLevel: 1,
  origin: {x: 20, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(41).fill(68), /* required buffer size: 41 */
{offset: 41}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup44 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 2, resource: {buffer: buffer11, size: 324}}],
});
try {
commandEncoder6.copyBufferToBuffer(buffer36, 0, buffer57, 64, 8);
} catch {}
try {
computePassEncoder9.setBindGroup(2, bindGroup11);
} catch {}
try {
commandEncoder59.copyBufferToTexture({
  /* bytesInLastRow: 720 widthInBlocks: 45 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1456 */
  offset: 1456,
  bytesPerRow: 9984,
  buffer: buffer2,
}, {
  texture: texture44,
  mipLevel: 0,
  origin: {x: 3, y: 23, z: 0},
  aspect: 'all',
}, {width: 45, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer60, 0, new Float32Array(10117).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.8606)), 503, 4);
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(195, 73);
let buffer65 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST});
let commandEncoder67 = device0.createCommandEncoder({});
try {
renderPassEncoder7.setBindGroup(1, bindGroup40, new Uint32Array(7688), 981, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup33, new Uint32Array(4534), 75, 0);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
document.body.append(img0);
await gc();
let commandBuffer8 = commandEncoder21.finish();
try {
renderPassEncoder10.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder10.drawIndexed(0, 2, 0, 298_732_212, 6);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer0, 'uint16', 0, 1);
} catch {}
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 8, resource: {buffer: buffer40}},
    {binding: 407, resource: {buffer: buffer11}},
    {binding: 0, resource: {buffer: buffer11}},
    {binding: 5, resource: textureView16},
    {binding: 3, resource: textureView26},
    {binding: 11, resource: textureView6},
  ],
});
let buffer66 = device0.createBuffer({size: 64, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder3.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup5, new Uint32Array(4814), 477, 0);
} catch {}
try {
renderPassEncoder10.draw(174, 2, 975_321_370, 5);
} catch {}
try {
renderPassEncoder10.drawIndexed(0, 3, 0, 75_881_382, 2);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer28, 'uint32', 40, 27);
} catch {}
try {
commandEncoder67.copyTextureToTexture({
  texture: texture39,
  mipLevel: 2,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture39,
  mipLevel: 2,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder54.resolveQuerySet(querySet0, 109, 0, buffer19, 0);
} catch {}
try {
commandEncoder2.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer7]);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView71 = texture40.createView({dimension: '2d-array', baseMipLevel: 0});
let renderPassEncoder22 = commandEncoder42.beginRenderPass({
  colorAttachments: [{view: textureView12, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 343138735,
});
let externalTexture10 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
await gc();
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'bt1361ExtendedColourGamut'} });
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 2, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {binding: 8, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 11, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {binding: 15, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 29,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 52,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 139,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 146,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
    {
      binding: 238,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 239,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 252,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 303,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 337,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 571,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let buffer67 = device0.createBuffer({size: 24, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandBuffer9 = commandEncoder6.finish();
let texture94 = device0.createTexture({
  size: {width: 45, height: 26, depthOrArrayLayers: 24},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView72 = texture60.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder10.drawIndexed(0, 5, 0, 40_489, 2);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer28, 'uint16', 36, 63);
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup37, [0]);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer11, 'uint32', 2_168, 234);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(4, buffer37);
} catch {}
let bindGroup46 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 2, resource: {buffer: buffer61, size: 60}}, {binding: 3, resource: {buffer: buffer61}}],
});
let commandEncoder68 = device0.createCommandEncoder({});
try {
renderPassEncoder12.setBindGroup(1, bindGroup36, new Uint32Array(1207), 14, 0);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer62, 36);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer2, 1_668, 2_811);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let pipeline12 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute1', constants: {}}});
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(255); };
} catch {}
let buffer68 = device0.createBuffer({size: 6556, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder69 = device0.createCommandEncoder();
let textureView73 = texture88.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1});
try {
renderPassEncoder10.draw(81, 5, 2_188_286_187, 1);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer62, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup2, new Uint32Array(925), 48, 0);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(4, buffer56, 0, 33);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 36, new DataView(new ArrayBuffer(46624)), 2128, 0);
} catch {}
try {
  await promise6;
} catch {}
let commandEncoder70 = device0.createCommandEncoder({});
let textureView74 = texture87.createView({});
try {
renderPassEncoder12.drawIndirect(buffer40, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer2, 1_316, 1_510);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer28, 'uint32', 52, 48);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu');
try {
device0.label = '\u95dc\ud94e\u1c4a\u08d0\u8b67\uc903\ub18d\u9cb6\u6fbc\ua9b1\u1d9a';
} catch {}
let textureView75 = texture92.createView({dimension: '2d-array', arrayLayerCount: 1});
let renderPassEncoder23 = commandEncoder70.beginRenderPass({
  colorAttachments: [{view: textureView58, depthSlice: 245, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder17.setBindGroup(0, bindGroup33);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer29, 64);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer61, 104);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline9);
} catch {}
try {
  await promise7;
} catch {}
let commandEncoder71 = device0.createCommandEncoder({});
let texture95 = device0.createTexture({
  size: [744, 3, 1],
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder24 = commandEncoder23.beginRenderPass({
  colorAttachments: [{
  view: textureView58,
  depthSlice: 50,
  clearValue: { r: -666.8, g: -89.29, b: -250.0, a: -349.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 175804413,
});
try {
renderPassEncoder10.draw(290, 1, 1_366_080_135, 1);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(5, buffer56, 0);
} catch {}
try {
commandEncoder45.resolveQuerySet(querySet1, 798, 6, buffer35, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 6, y: 6 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer69 = device0.createBuffer({
  size: 8,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder72 = device0.createCommandEncoder({});
try {
renderBundleEncoder2.setVertexBuffer(7, buffer37, 0, 21);
} catch {}
try {
commandEncoder55.copyTextureToTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 9, y: 11, z: 0},
  aspect: 'all',
},
{
  texture: texture79,
  mipLevel: 0,
  origin: {x: 828, y: 9, z: 0},
  aspect: 'all',
},
{width: 204, height: 11, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer8, commandBuffer9]);
} catch {}
let commandEncoder73 = device0.createCommandEncoder();
let sampler16 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
renderPassEncoder10.draw(218, 1, 551_946_116, 2);
} catch {}
try {
renderPassEncoder10.drawIndexed(0, 1, 0, 90_313_394, 1);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer10, 4);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer29, 16);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup37, [0]);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer11, 'uint16', 340, 73);
} catch {}
let imageData9 = new ImageData(40, 12);
let bindGroup47 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 146, resource: textureView60},
    {binding: 238, resource: {buffer: buffer40}},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 571, resource: textureView65},
    {binding: 139, resource: textureView74},
    {binding: 252, resource: textureView17},
    {binding: 2, resource: externalTexture1},
    {binding: 52, resource: textureView61},
    {binding: 239, resource: textureView62},
    {binding: 11, resource: sampler4},
    {binding: 29, resource: {buffer: buffer11}},
    {binding: 153, resource: sampler4},
    {binding: 1, resource: {buffer: buffer11}},
    {binding: 303, resource: {buffer: buffer11}},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 15, resource: externalTexture4},
    {binding: 43, resource: sampler4},
    {binding: 44, resource: {buffer: buffer54}},
    {binding: 0, resource: textureView60},
    {binding: 8, resource: {buffer: buffer34}},
  ],
});
try {
renderPassEncoder10.drawIndexed(0, 1, 0, -1_581_944_524, 1);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer0, 'uint16', 0, 1);
} catch {}
let texture96 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 11},
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView76 = texture57.createView({format: 'r16uint', mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder10.draw(333, 1, 1_017_819_205);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(3, buffer51, 0, 13);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup19, new Uint32Array(3975), 41, 0);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(0, buffer56, 88, 23);
} catch {}
let commandEncoder74 = device0.createCommandEncoder();
let textureView77 = texture96.createView({});
let textureView78 = texture42.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 1});
try {
renderPassEncoder15.setBindGroup(1, bindGroup2, new Uint32Array(842), 90, 0);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer39, 228);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer32, 'uint32', 36, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline10);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer69, 0, new DataView(new ArrayBuffer(83536)), 6425, 0);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(56); };
} catch {}
let textureView79 = texture82.createView({baseArrayLayer: 0, arrayLayerCount: 3});
try {
computePassEncoder18.setBindGroup(0, bindGroup15);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer40, 8); };
} catch {}
try {
renderPassEncoder10.beginOcclusionQuery(2121);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer17, 'uint32', 40, 6);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline9);
} catch {}
try {
commandEncoder72.clearBuffer(buffer66);
} catch {}
try {
commandEncoder45.resolveQuerySet(querySet0, 680, 0, buffer67, 0);
} catch {}
try {
renderPassEncoder24.insertDebugMarker('\u06f8');
} catch {}
document.body.append(img0);
let canvas0 = document.createElement('canvas');
try {
computePassEncoder9.setBindGroup(1, bindGroup47, new Uint32Array(3513), 64, 2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer34, 20); };
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(277);
} catch {}
try {
renderPassEncoder20.setBlendConstant({ r: 213.2, g: -286.5, b: -718.2, a: 885.7, });
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer38, 0);
} catch {}
let buffer70 = device0.createBuffer({size: 24, usage: GPUBufferUsage.QUERY_RESOLVE});
let sampler17 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 68.99, compare: 'less'});
try {
renderPassEncoder12.drawIndirect(buffer40, 144);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, buffer0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer18, 'uint16', 14, 12);
} catch {}
try {
commandEncoder38.clearBuffer(buffer32);
} catch {}
try {
texture43.label = '\u00d2\u0907\u4cc6\u0ced\ufb17\u{1f84d}\ubc8f\u016a\u013d\ud9cf';
} catch {}
let bindGroup48 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 90, resource: textureView43},
    {binding: 2, resource: {buffer: buffer11}},
    {binding: 0, resource: textureView0},
    {binding: 1, resource: externalTexture10},
    {binding: 3, resource: {buffer: buffer54}},
  ],
});
let buffer71 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let texture97 = device0.createTexture({
  size: {width: 586, height: 12, depthOrArrayLayers: 57},
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView80 = texture68.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder10.drawIndexed(0, 2, 0, 295_409_380);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer10, 4);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer67, 0);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup33);
} catch {}
try {
buffer64.unmap();
} catch {}
try {
computePassEncoder12.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup39, [0]);
} catch {}
try {
renderPassEncoder12.draw(161, 11, 521_050_915, 2);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 7, 1, 54_353_517, 7);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer18, 80);
} catch {}
try {
commandEncoder62.insertDebugMarker('\uc87d');
} catch {}
document.body.prepend(canvas0);
try {
renderPassEncoder16.executeBundles([renderBundle1, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer18, 12);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer32, 'uint32', 44, 29);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup39, [0]);
} catch {}
try {
commandEncoder18.insertDebugMarker('\u7442');
} catch {}
try {
device0.queue.writeBuffer(buffer59, 0, new DataView(new Uint8Array(4314).map((_, i) => i).buffer), 693, 8);
} catch {}
let gpuCanvasContext2 = canvas0.getContext('webgpu');
let offscreenCanvas2 = new OffscreenCanvas(344, 45);
let bindGroup49 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 1, resource: {buffer: buffer11}},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 571, resource: textureView73},
    {binding: 15, resource: externalTexture10},
    {binding: 11, resource: sampler6},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 29, resource: {buffer: buffer11}},
    {binding: 252, resource: textureView70},
    {binding: 0, resource: textureView60},
    {binding: 8, resource: {buffer: buffer38}},
    {binding: 2, resource: externalTexture7},
    {binding: 139, resource: textureView74},
    {binding: 238, resource: {buffer: buffer62, size: 28}},
    {binding: 146, resource: textureView60},
    {binding: 44, resource: {buffer: buffer34}},
    {binding: 239, resource: textureView62},
    {binding: 43, resource: sampler16},
    {binding: 153, resource: sampler8},
    {binding: 303, resource: {buffer: buffer11}},
    {binding: 52, resource: textureView61},
  ],
});
let commandEncoder75 = device0.createCommandEncoder({});
let externalTexture11 = device0.importExternalTexture({source: videoFrame5});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer67, 0); };
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer40, 8);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer71, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer51, 0, 40);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint16', 0, 0);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(0, buffer9, 0, 47);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder10.draw(97, 1, 209_050_065);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: img1,
  origin: { x: 0, y: 18 },
  flipY: false,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 4, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(97, 165);
let imageData10 = new ImageData(76, 36);
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 7, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 18, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 38,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 84,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 159,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 181,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 187,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 202,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 244,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup50 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 0, resource: textureView51},
    {binding: 1, resource: externalTexture4},
    {binding: 2, resource: {buffer: buffer34}},
    {binding: 3, resource: {buffer: buffer40, size: 124}},
    {binding: 90, resource: textureView8},
  ],
});
let buffer72 = device0.createBuffer({
  size: 1024,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder76 = device0.createCommandEncoder({});
let commandBuffer10 = commandEncoder2.finish({});
let renderBundle2 = renderBundleEncoder10.finish({});
try {
renderPassEncoder20.setBindGroup(1, bindGroup33);
} catch {}
try {
renderPassEncoder12.draw(78, 5, 80_120_528, 7);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer71, 4);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer32, 'uint16', 36, 1);
} catch {}
try {
commandEncoder40.copyBufferToBuffer(buffer32, 12, buffer59, 4, 0);
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup26, new Uint32Array(88), 17, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer30, 32, 99);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup36);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture43,
  mipLevel: 1,
  origin: {x: 56, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(11).fill(254), /* required buffer size: 11 */
{offset: 11, rowsPerImage: 45}, {width: 144, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline13 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}});
let commandEncoder78 = device0.createCommandEncoder({});
let texture98 = device0.createTexture({
  size: {width: 102, height: 1, depthOrArrayLayers: 4},
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView81 = texture73.createView({dimension: '3d', mipLevelCount: 1});
try {
renderPassEncoder12.setBindGroup(0, bindGroup32);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup32, new Uint32Array(1574), 88, 0);
} catch {}
try {
renderPassEncoder10.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup36, new Uint32Array(1092), 1, 0);
} catch {}
try {
renderBundleEncoder7.drawIndexed(98, 0, 11, 4_172_048);
} catch {}
try {
renderBundleEncoder3.insertDebugMarker('\u2214');
} catch {}
let buffer73 = device0.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let texture99 = device0.createTexture({
  label: '\u385e\u5e48\u0e08\u0b58\udda0\u{1ff19}\u206c\ufad2',
  size: [372, 1, 26],
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder12.draw(4, 5, 976_766_815, 10);
} catch {}
try {
renderPassEncoder12.drawIndexed(5, 18, 0, -2_123_902_723, 3);
} catch {}
try {
renderBundleEncoder7.draw(193, 0, 1_453_328_961);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer10, 0);
} catch {}
try {
commandEncoder71.copyBufferToTexture({
  /* bytesInLastRow: 832 widthInBlocks: 52 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1024 */
  offset: 1024,
  bytesPerRow: 2304,
  buffer: buffer72,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 748, y: 6, z: 0},
  aspect: 'all',
}, {width: 52, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder8.insertDebugMarker('\u{1fe81}');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext3 = offscreenCanvas2.getContext('webgpu');
let commandEncoder79 = device0.createCommandEncoder({});
let renderPassEncoder25 = commandEncoder60.beginRenderPass({
  colorAttachments: [{
  view: textureView58,
  depthSlice: 77,
  clearValue: { r: 848.7, g: 225.2, b: 855.3, a: 527.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 627488907,
});
try {
computePassEncoder22.setBindGroup(2, bindGroup21, new Uint32Array(1872), 158, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(3, 1, 1); };
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer18, 4);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer22, 4, 29);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(5, buffer2);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(45); };
} catch {}
try {
globalThis.someLabel = externalTexture11.label;
} catch {}
let buffer74 = device0.createBuffer({size: 111, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder80 = device0.createCommandEncoder({});
let texture100 = device0.createTexture({
  size: [45, 26, 1],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder16.setBindGroup(1, bindGroup35, new Uint32Array(661), 25, 1);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup2, new Uint32Array(165), 56, 0);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer21, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 2,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(13).fill(105), /* required buffer size: 13 */
{offset: 13, bytesPerRow: 289, rowsPerImage: 28}, {width: 92, height: 8, depthOrArrayLayers: 0});
} catch {}
let textureView82 = texture31.createView({label: '\u0772\u{1fda5}\u1642\u{1ffb8}\u{1f6e9}', baseArrayLayer: 1, arrayLayerCount: 2});
try {
computePassEncoder23.setBindGroup(0, bindGroup49, [0, 0]);
} catch {}
try {
renderPassEncoder12.draw(503, 12, 2_206_942_001, 1);
} catch {}
try {
renderPassEncoder10.drawIndexed(0, 9, 0, 646_212_547);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer32, 'uint32', 12, 12);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline6);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext4 = offscreenCanvas3.getContext('webgpu');
let bindGroup51 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 2, resource: {buffer: buffer11}}, {binding: 3, resource: {buffer: buffer10}}],
});
let textureView83 = texture99.createView({baseMipLevel: 0, baseArrayLayer: 0});
try {
renderPassEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(260), 63, 0);
} catch {}
try {
renderPassEncoder10.beginOcclusionQuery(2231);
} catch {}
try {
renderPassEncoder10.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.draw(3, 33, 535_534_121, 3);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer21, 8);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer0, 'uint32', 0, 3);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(6, buffer56, 0, 43);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData11 = new ImageData(24, 80);
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'pq'} });
let commandEncoder81 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer40, 48); };
} catch {}
try {
renderPassEncoder25.setBindGroup(1, bindGroup19);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer21, 4);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer61, 28);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup34);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup50, new Uint32Array(833), 176, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 4, new DataView(new ArrayBuffer(60240)), 100, 0);
} catch {}
let commandEncoder82 = device0.createCommandEncoder({});
let texture101 = device0.createTexture({
  size: [2345],
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView84 = texture27.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer72, 144); };
} catch {}
try {
computePassEncoder20.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder12.draw(577, 6, 449_684_568, 0);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer39, 96);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer12);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(4, buffer2);
} catch {}
try {
device0.queue.writeBuffer(buffer17, 76, new Uint32Array(11291).map((_, i) => i * 7), 120, 0);
} catch {}
try {
computePassEncoder17.setBindGroup(2, bindGroup3);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup1, new Uint32Array(96), 4, 0);
} catch {}
try {
renderPassEncoder12.draw(156, 25, 313_396_820, 2);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 3, 0, 1_083_523_195, 2);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer11, 'uint32', 3_132, 96);
} catch {}
try {
renderBundleEncoder17.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer10, 16);
} catch {}
try {
buffer33.unmap();
} catch {}
try {
commandEncoder45.copyTextureToTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 5, y: 9, z: 0},
  aspect: 'all',
},
{
  texture: texture72,
  mipLevel: 0,
  origin: {x: 315, y: 0, z: 0},
  aspect: 'all',
},
{width: 50, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let autogeneratedBindGroupLayout5 = pipeline3.getBindGroupLayout(1);
let bindGroup52 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer1}},
    {binding: 1, resource: externalTexture4},
    {binding: 3, resource: {buffer: buffer40}},
    {binding: 0, resource: textureView1},
  ],
});
let commandEncoder83 = device0.createCommandEncoder();
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup31);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer71, 4);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
commandEncoder77.clearBuffer(buffer17);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new DataView(new Uint8Array(6800).map((_, i) => i).buffer), 1843, 4);
} catch {}
let bindGroup53 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 2, resource: {buffer: buffer61}}]});
try {
renderPassEncoder12.drawIndirect(buffer72, 32);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(6, buffer30, 100, 68);
} catch {}
try {
renderBundleEncoder21.setBindGroup(3, bindGroup43);
} catch {}
try {
renderBundleEncoder20.setBindGroup(3, bindGroup41, new Uint32Array(2444), 998, 0);
} catch {}
try {
renderPassEncoder12.insertDebugMarker('\u0e2c');
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
offscreenCanvas0.width = 556;
let textureView85 = texture97.createView({baseArrayLayer: 0});
try {
computePassEncoder8.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer11, 'uint16', 166, 1_005);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, buffer74, 28, 5);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup2);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer40, 92);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer11, 'uint16', 638, 177);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(0, buffer74, 8);
} catch {}
let pipeline14 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  fragment: {module: shaderModule4, constants: {}, targets: [{format: 'r16uint', writeMask: 0}]},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex1',
    buffers: [
      {
        arrayStride: 56,
        attributes: [
          {format: 'snorm16x2', offset: 4, shaderLocation: 1},
          {format: 'sint8x2', offset: 4, shaderLocation: 4},
          {format: 'snorm16x2', offset: 28, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front'},
});
let externalTexture12 = device0.importExternalTexture({source: videoFrame10});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer18, 16);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup52);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer61, 8);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline6);
} catch {}
try {
device0.queue.writeBuffer(buffer57, 56, new DataView(new Uint8Array(12540).map((_, i) => i).buffer), 2990, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(1_739).fill(121), /* required buffer size: 1_739 */
{offset: 161, bytesPerRow: 14, rowsPerImage: 110}, {width: 5, height: 3, depthOrArrayLayers: 2});
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(1259);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 2, 2, 794_521_274, 3);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer21, 4);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer18, 'uint16', 8, 6);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup9, new Uint32Array(44), 5, 0);
} catch {}
try {
renderBundleEncoder7.draw(185, 0, 733_728_356);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer61, 200);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer0, 'uint16', 2, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer69, 0, new DataView(new ArrayBuffer(4841)), 383, 0);
} catch {}
let commandEncoder84 = device0.createCommandEncoder({});
let texture102 = device0.createTexture({
  size: {width: 45},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView86 = texture9.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder10.drawIndexed(0, 5, 0, -1_487_896_576, 0);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer39, 80);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
commandEncoder59.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 60 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2244 */
  offset: 2244,
  bytesPerRow: 11008,
  buffer: buffer2,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
}, {width: 60, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder85 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  size: [408, 1, 14],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder27 = commandEncoder82.beginComputePass();
try {
renderPassEncoder9.setBindGroup(0, bindGroup14, new Uint32Array(127), 64, 0);
} catch {}
try {
renderBundleEncoder22.setBindGroup(1, bindGroup6, new Uint32Array(448), 6, 0);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer61, 88);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(1, buffer13, 0, 1);
} catch {}
try {
commandEncoder77.copyBufferToBuffer(buffer68, 828, buffer54, 8, 4);
} catch {}
try {
commandEncoder51.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 432 */
  offset: 432,
  rowsPerImage: 324,
  buffer: buffer72,
}, {
  texture: texture94,
  mipLevel: 2,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer28, 64, new Float16Array(8318).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.3965)), 6258, 4);
} catch {}
let commandEncoder86 = device0.createCommandEncoder({});
let computePassEncoder28 = commandEncoder74.beginComputePass();
try {
computePassEncoder14.setBindGroup(1, bindGroup36);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup1, new Uint32Array(1586), 283, 0);
} catch {}
try {
renderPassEncoder12.draw(90, 11, 440_317_497, 11);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer61, 56);
} catch {}
try {
renderBundleEncoder6.draw(40, 1, 447_279_754);
} catch {}
try {
renderBundleEncoder6.drawIndexed(1, 1, 0, 83_279_208, 0);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer62, 4);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(4, buffer37, 24, 44);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 4, new DataView(new ArrayBuffer(169008)), 4717, 0);
} catch {}
let texture104 = device0.createTexture({
  size: {width: 90, height: 52, depthOrArrayLayers: 111},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView87 = texture28.createView({mipLevelCount: 1, arrayLayerCount: 3});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({
  label: '\u6411\u{1f8d6}\uf1ec\ud4d9\uf0f9\u{1fe51}',
  colorFormats: ['r16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder28.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup33, new Uint32Array(2184), 27, 0);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 4, 0, 361_001_409);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer39, 112);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let buffer75 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let textureView88 = texture55.createView({});
let externalTexture13 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder16.setBindGroup(3, bindGroup50, new Uint32Array(700), 40, 0);
} catch {}
try {
renderPassEncoder7.drawIndexed(6, 0, 0, 317_792_812);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer71, 'uint32', 16, 8);
} catch {}
try {
renderBundleEncoder7.draw(46, 0, 131_386_737);
} catch {}
try {
buffer35.unmap();
} catch {}
let commandEncoder87 = device0.createCommandEncoder({label: '\uade0\u0c3a\ud87d'});
let textureView89 = texture14.createView({dimension: '2d-array', format: 'rgba16uint'});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer18, 36); };
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer62, 76);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup15, []);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(7, buffer30);
} catch {}
let commandEncoder88 = device0.createCommandEncoder({});
let texture105 = device0.createTexture({
  size: [586],
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder15.setBindGroup(2, bindGroup26, new Uint32Array(831), 272, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup30, new Uint32Array(93), 1, 0);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 5, 0, 77_529_005, 2);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer72, 216);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer39, 112);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer71, 'uint32', 0, 66);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup7);
} catch {}
try {
renderBundleEncoder7.draw(252, 0, 371_283_227);
} catch {}
let bindGroup54 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 2, resource: {buffer: buffer22, offset: 0, size: 12}}],
});
let texture106 = device0.createTexture({
  label: '\uc871\u06c0\u0839\uedb6\u020c\u{1f789}\u0468\u0859\uaae4\udf04\u06c9',
  size: {width: 204, height: 1, depthOrArrayLayers: 21},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture107 = device0.createTexture({
  size: [64, 64, 20],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder26 = commandEncoder40.beginRenderPass({colorAttachments: [{view: textureView47, depthSlice: 0, loadOp: 'load', storeOp: 'discard'}]});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(2, 1); };
} catch {}
try {
renderPassEncoder10.draw(490, 1, 992_096_352);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer40, 24);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer21, 8);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer0, 'uint32', 0, 6);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup38);
} catch {}
try {
renderBundleEncoder7.draw(126, 0, 830_038_449);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer39, 56);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer62, 4);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline14);
} catch {}
let img2 = await imageWithData(3, 170, '#10101010', '#20202020');
let textureView90 = texture106.createView({});
let textureView91 = texture98.createView({arrayLayerCount: 1});
let externalTexture14 = device0.importExternalTexture({source: videoFrame7});
try {
renderPassEncoder7.drawIndirect(buffer62, 8);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer32, 'uint16', 80, 35);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline14);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let arrayBuffer2 = buffer23.getMappedRange(216, 132);
try {
device0.queue.writeBuffer(buffer59, 0, new Uint16Array(8953).map((_, i) => i + 10), 2932, 0);
} catch {}
let buffer76 = device0.createBuffer({size: 380, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder89 = device0.createCommandEncoder({});
let textureView92 = texture105.createView({});
let renderBundle3 = renderBundleEncoder6.finish();
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer67, 0); };
} catch {}
try {
computePassEncoder18.end();
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup48);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(862);
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 2, -1_880_783_040);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer2);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer21, 8);
} catch {}
let bindGroup55 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 2, resource: {buffer: buffer28}}]});
let buffer77 = device0.createBuffer({
  size: 360,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView93 = texture106.createView({});
try {
renderPassEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(1406), 121, 0);
} catch {}
try {
renderPassEncoder10.draw(130, 5, 3_046_426_997, 3);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer72, 'uint16', 2, 29);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup1, new Uint32Array(607), 39, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline9);
} catch {}
document.body.prepend(img2);
let bindGroup56 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 2, resource: {buffer: buffer76}}]});
let commandEncoder90 = device0.createCommandEncoder({});
let texture108 = device0.createTexture({
  size: {width: 816},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder12.drawIndexed(4, 8, 1, -1_899_078_951, 6);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer72, 52);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(1, buffer56);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline9);
} catch {}
try {
commandEncoder84.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 24, y: 30, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 208 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 688 */
  offset: 688,
  bytesPerRow: 768,
  buffer: buffer11,
}, {width: 78, height: 15, depthOrArrayLayers: 0});
} catch {}
let commandEncoder91 = device0.createCommandEncoder({});
let textureView94 = texture105.createView({});
let texture109 = device0.createTexture({size: {width: 2976}, dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.draw(370, 0, 227_908_035);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer72, 300);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline6);
} catch {}
try {
commandEncoder76.copyBufferToTexture({
  /* bytesInLastRow: 2592 widthInBlocks: 162 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 768 */
  offset: 768,
  buffer: buffer2,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 172, y: 1, z: 0},
  aspect: 'all',
}, {width: 162, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 102, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture18,
  mipLevel: 3,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture110 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder20.setBindGroup(0, bindGroup6, new Uint32Array(149), 14, 0);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer0, 'uint16', 0, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 1,
  origin: {x: 40, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(17).fill(51), /* required buffer size: 17 */
{offset: 17, rowsPerImage: 56}, {width: 380, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise9 = device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule2}});
let commandBuffer11 = commandEncoder49.finish();
try {
computePassEncoder14.setBindGroup(1, bindGroup48);
} catch {}
try {
renderPassEncoder12.draw(30, 3, 1_512_719_119);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer71, 12);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer11, 'uint32', 260, 25);
} catch {}
try {
commandEncoder89.copyTextureToTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture75,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise8;
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'bt2020_12bit'} });
let bindGroup57 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 11, resource: sampler1},
    {binding: 44, resource: {buffer: buffer54, size: 4}},
    {binding: 303, resource: {buffer: buffer11, offset: 768}},
    {binding: 238, resource: {buffer: buffer62, size: 8}},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 571, resource: textureView65},
    {binding: 239, resource: textureView62},
    {binding: 1, resource: {buffer: buffer11}},
    {binding: 15, resource: externalTexture3},
    {binding: 139, resource: textureView63},
    {binding: 43, resource: sampler16},
    {binding: 8, resource: {buffer: buffer40}},
    {binding: 52, resource: textureView77},
    {binding: 153, resource: sampler16},
    {binding: 0, resource: textureView60},
    {binding: 2, resource: externalTexture8},
    {binding: 29, resource: {buffer: buffer11}},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 146, resource: textureView60},
    {binding: 252, resource: textureView78},
  ],
});
let commandEncoder92 = device0.createCommandEncoder({});
let textureView95 = texture68.createView({});
try {
computePassEncoder24.setBindGroup(0, bindGroup14, new Uint32Array(466), 45, 0);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer40, 64);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup8, new Uint32Array(371), 43, 0);
} catch {}
try {
commandEncoder45.copyBufferToTexture({
  /* bytesInLastRow: 44 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1430 */
  offset: 1430,
  rowsPerImage: 175,
  buffer: buffer68,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, {width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup58 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 2, resource: {buffer: buffer40}}]});
let buffer78 = device0.createBuffer({size: 76, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder20.setBindGroup(1, bindGroup11, new Uint32Array(2969), 218, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 4, 0, 1_243_133_956, 24);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer72, 204);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(5, buffer30, 0, 4);
} catch {}
try {
buffer74.unmap();
} catch {}
let commandEncoder93 = device0.createCommandEncoder({});
let textureView96 = texture24.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder10.draw(1_000, 1, 1_405_823_382, 2);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer39, 4);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline4);
} catch {}
let bindGroup59 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 2, resource: {buffer: buffer40}}]});
let textureView97 = texture78.createView({});
let computePassEncoder29 = commandEncoder93.beginComputePass();
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMinClamp: 86.91,
  lodMaxClamp: 97.09,
});
try {
computePassEncoder29.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder10.end();
} catch {}
try {
renderPassEncoder20.setScissorRect(76, 0, 541, 0);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer78, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup30, new Uint32Array(1097), 161, 0);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer61, 0);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer61, 116);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer72, 'uint16', 38, 45);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(6, buffer9);
} catch {}
try {
buffer65.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer59, 4, new Uint32Array(19196).map((_, i) => i * 7), 2156, 0);
} catch {}
let imageData12 = new ImageData(4, 40);
let autogeneratedBindGroupLayout6 = pipeline3.getBindGroupLayout(1);
let bindGroup60 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 0, resource: textureView51},
    {binding: 1, resource: externalTexture9},
    {binding: 2, resource: {buffer: buffer40}},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer10}},
  ],
});
try {
computePassEncoder24.setBindGroup(1, bindGroup31, new Uint32Array(1733), 541, 0);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer21, 0);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer34, 40);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer71, 'uint16', 0, 13);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(4, buffer13, 0);
} catch {}
let texture111 = device0.createTexture({
  size: [586],
  sampleCount: 1,
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder20.end();
} catch {}
try {
renderPassEncoder19.setVertexBuffer(1, buffer2, 0, 1_946);
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup27, new Uint32Array(1088), 46, 0);
} catch {}
try {
renderBundleEncoder7.draw(142, 0, 1_240_170_267);
} catch {}
let bindGroup61 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 90, resource: textureView57},
    {binding: 0, resource: textureView51},
    {binding: 3, resource: {buffer: buffer40}},
    {binding: 1, resource: externalTexture13},
    {binding: 2, resource: {buffer: buffer54}},
  ],
});
let commandEncoder94 = device0.createCommandEncoder({});
try {
renderPassEncoder7.drawIndexed(2, 0, 0, 652_040_858);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer1);
} catch {}
try {
commandEncoder18.resolveQuerySet(querySet0, 247, 2, buffer22, 0);
} catch {}
try {
renderBundle2.label = '\u7323\u0be3\udbac\u{1fd02}\u{1f649}';
} catch {}
let textureView98 = texture5.createView({arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer39, 4); };
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer39, 24);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup7);
} catch {}
try {
renderBundleEncoder7.drawIndexed(72, 0, 0, 218_412_114);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(6, buffer37, 44, 19);
} catch {}
let arrayBuffer3 = buffer23.getMappedRange(2984, 9188);
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.prepend(img1);
let buffer79 = device0.createBuffer({size: 196, usage: GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder26.setBindGroup(1, bindGroup34);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer78, 4);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer13);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup50, new Uint32Array(1616), 64, 0);
} catch {}
try {
renderBundleEncoder7.draw(27, 0, 405_157_694, 0);
} catch {}
try {
renderBundleEncoder7.drawIndexed(153, 0, 10, -1_849_228_944);
} catch {}
try {
buffer23.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer11]);
} catch {}
let pipeline15 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}});
let texture112 = device0.createTexture({
  size: {width: 102},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer77, 56); };
} catch {}
try {
renderPassEncoder7.draw(85, 0, 1_003_017_575);
} catch {}
let commandEncoder95 = device0.createCommandEncoder({});
let textureView99 = texture69.createView({dimension: '3d', mipLevelCount: 1});
let externalTexture15 = device0.importExternalTexture({source: videoFrame5, colorSpace: 'srgb'});
try {
computePassEncoder8.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer51, 0, 42);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup17, [0]);
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u{1fd91}');
} catch {}
try {
device0.queue.submit([commandBuffer10]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(81).fill(183), /* required buffer size: 81 */
{offset: 81}, {width: 408, height: 0, depthOrArrayLayers: 0});
} catch {}
let img3 = await imageWithData(76, 78, '#10101010', '#20202020');
let bindGroup62 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 52, resource: {buffer: buffer61}}]});
let buffer80 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let texture113 = device0.createTexture({
  size: [204, 1, 1],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder7.drawIndexed(2, 0, 0, -2_124_681_011);
} catch {}
try {
renderBundleEncoder7.draw(156, 0, 163_423_845);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let commandEncoder96 = device0.createCommandEncoder({});
let textureView100 = texture52.createView({dimension: '1d'});
let computePassEncoder30 = commandEncoder88.beginComputePass();
let renderBundle4 = renderBundleEncoder7.finish({});
try {
renderPassEncoder12.draw(235, 7, 2_545_198_489, 1);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer71, 12);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(0, buffer2, 0);
} catch {}
try {
commandEncoder64.copyTextureToTexture({
  texture: texture92,
  mipLevel: 0,
  origin: {x: 412, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture60,
  mipLevel: 1,
  origin: {x: 87, y: 0, z: 2},
  aspect: 'all',
},
{width: 25, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 24,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 70,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '3d' },
    },
  ],
});
let texture114 = device0.createTexture({
  size: {width: 204, height: 1, depthOrArrayLayers: 195},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder27 = commandEncoder55.beginRenderPass({
  colorAttachments: [{view: textureView18, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder17.setBindGroup(3, bindGroup7);
} catch {}
try {
computePassEncoder30.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup51, new Uint32Array(552), 102, 0);
} catch {}
try {
renderPassEncoder12.draw(231, 2, 20_124_675, 11);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(7, buffer51, 4);
} catch {}
try {
commandEncoder86.resolveQuerySet(querySet1, 129, 1, buffer70, 0);
} catch {}
let textureView101 = texture114.createView({});
try {
renderPassEncoder15.setBindGroup(2, bindGroup62, [0]);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer39, 296);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer72);
} catch {}
let promise10 = shaderModule3.getCompilationInfo();
await gc();
let bindGroup63 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 0, resource: textureView51},
    {binding: 1, resource: externalTexture10},
    {binding: 3, resource: {buffer: buffer64}},
    {binding: 90, resource: textureView57},
    {binding: 2, resource: {buffer: buffer40}},
  ],
});
let commandEncoder97 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 0, 688_849_038);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer29, 252);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(2, buffer9, 212, 0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup56, new Uint32Array(1570), 230, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 408, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView102 = texture114.createView({});
try {
computePassEncoder16.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder7.draw(141, 0, 229_415_640);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer62, 8);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer61, 32);
} catch {}
try {
renderBundleEncoder23.setBindGroup(0, bindGroup52);
} catch {}
try {
buffer60.unmap();
} catch {}
offscreenCanvas1.width = 271;
let textureView103 = texture13.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1});
try {
computePassEncoder26.setBindGroup(0, bindGroup11, new Uint32Array(209), 5, 0);
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 0, 114_639_628);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer62, 8);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer71, 'uint32', 0, 21);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(0, buffer37, 0, 5);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new Uint32Array(10813).map((_, i) => i * 4), 1136, 0);
} catch {}
let pipeline16 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule4}});
try {
  await promise10;
} catch {}
try {
computePassEncoder28.setBindGroup(1, bindGroup0);
} catch {}
try {
computePassEncoder9.setBindGroup(3, bindGroup38, new Uint32Array(1775), 1_291, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer21, 36); };
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 3, 1, -1_597_462_266, 5);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer40, 4);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder18.setBindGroup(3, bindGroup5);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline9);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer45, 36, new Uint32Array(8454).map((_, i) => i * 6), 86, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 94 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 226, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder98 = device0.createCommandEncoder({});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 9});
try {
computePassEncoder14.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder12.drawIndexed(4, 2, 0, 101_463_108, 11);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer40, 0);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer21, 0);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline14);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 1832 widthInBlocks: 458 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3028 */
  offset: 3028,
  bytesPerRow: 13056,
  rowsPerImage: 193,
  buffer: buffer2,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, {width: 458, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer11, 480, new Float32Array(8002).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.411)), 1152, 16);
} catch {}
document.body.append(img1);
await gc();
let bindGroup64 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 1, resource: externalTexture4},
    {binding: 0, resource: textureView1},
    {binding: 3, resource: {buffer: buffer64}},
    {binding: 90, resource: textureView43},
    {binding: 2, resource: {buffer: buffer76}},
  ],
});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
try {
renderPassEncoder7.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer0, 'uint32', 0, 2);
} catch {}
try {
commandEncoder81.resolveQuerySet(querySet1, 39, 0, buffer19, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas1,
  origin: { x: 92, y: 8 },
  flipY: false,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let renderBundle5 = renderBundleEncoder0.finish({});
try {
computePassEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 1, 0, 262_562_489, 5);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup35, [0]);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline14);
} catch {}
let texture115 = device0.createTexture({
  size: [1172, 24, 1],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder29.setBindGroup(2, bindGroup53);
} catch {}
try {
computePassEncoder26.setBindGroup(0, bindGroup25, new Uint32Array(1502), 41, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 2, 285_935_436);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer34, 68);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer22, 32, 4);
} catch {}
try {
commandEncoder67.copyBufferToTexture({
  /* bytesInLastRow: 14 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 962 */
  offset: 962,
  buffer: buffer2,
}, {
  texture: texture70,
  mipLevel: 3,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
try {
renderBundleEncoder4.setIndexBuffer(buffer32, 'uint16', 4, 9);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(4, buffer11, 0, 138);
} catch {}
document.body.append(canvas0);
let commandBuffer12 = commandEncoder44.finish();
let texture116 = device0.createTexture({size: {width: 102}, dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder17.setBindGroup(2, bindGroup61, []);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup14, []);
} catch {}
try {
renderPassEncoder12.drawIndexed(4, 1, 1, 355_410_771, 16);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer37, 8, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer66, 40, new Float32Array(7172).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.553)), 482, 0);
} catch {}
let commandEncoder99 = device0.createCommandEncoder({});
try {
computePassEncoder17.setBindGroup(2, bindGroup56);
} catch {}
try {
computePassEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(350), 21, 0);
} catch {}
try {
renderPassEncoder12.draw(486, 14, 65_776_310, 2);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer18, 4);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer71, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer17, 'uint32', 8, 1);
} catch {}
try {
commandEncoder96.clearBuffer(buffer80);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
renderPassEncoder12.draw(202, 7, 108_483_282, 27);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer10, 4);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer0, 'uint16', 2, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline10);
} catch {}
try {
device0.queue.writeBuffer(buffer54, 12, new Uint32Array(37484).map((_, i) => i * 9), 3407, 0);
} catch {}
try {
textureView88.label = '\u03b4\u8d8a\u0489\u17aa';
} catch {}
let bindGroup65 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer76}},
    {binding: 90, resource: textureView43},
    {binding: 3, resource: {buffer: buffer34}},
    {binding: 1, resource: externalTexture6},
  ],
});
let commandEncoder100 = device0.createCommandEncoder({});
let texture117 = gpuCanvasContext2.getCurrentTexture();
let textureView104 = texture54.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 3});
let sampler19 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', compare: 'never'});
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder12.drawIndexed(4, 4, 0, 818_667_836, 11);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer71, 0);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer77, 'uint16', 4, 12);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup18, new Uint32Array(2694), 238, 1);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(7, buffer74);
} catch {}
try {
commandEncoder10.clearBuffer(buffer60);
} catch {}
try {
externalTexture2.label = '\u{1f732}\u0dbb';
} catch {}
let bindGroup66 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 52, resource: {buffer: buffer76, size: 68}}],
});
let buffer81 = device0.createBuffer({size: 4, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder101 = device0.createCommandEncoder({});
let textureView105 = texture82.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2});
let textureView106 = texture106.createView({});
try {
computePassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 1, 1, -1_957_484_363, 11);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer10, 8);
} catch {}
let arrayBuffer4 = buffer46.getMappedRange(0, 0);
try {
buffer36.unmap();
} catch {}
try {
commandEncoder77.resolveQuerySet(querySet0, 122, 0, buffer75, 0);
} catch {}
let texture118 = device0.createTexture({
  size: {width: 816},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder12.setBlendConstant({ r: -336.4, g: 619.0, b: -79.68, a: 680.3, });
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer77, 128);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer17, 'uint32', 16, 17);
} catch {}
try {
commandEncoder71.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 708 */
  offset: 708,
  bytesPerRow: 14592,
  buffer: buffer72,
}, {
  texture: texture77,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer80, 12, new DataView(new Uint8Array(1062).map((_, i) => i).buffer), 52, 32);
} catch {}
let videoFrame14 = new VideoFrame(offscreenCanvas0, {timestamp: 0});
let textureView107 = texture54.createView({arrayLayerCount: 3});
try {
computePassEncoder19.setBindGroup(2, bindGroup39, new Uint32Array(4955), 40, 1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer21, 20); };
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup13, new Uint32Array(1199), 52, 0);
} catch {}
try {
renderPassEncoder12.draw(21, 3, 432_109_156, 30);
} catch {}
try {
renderPassEncoder12.drawIndexed(4, 4, 1, 93_908_973, 3);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer21, 4);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder19.setBindGroup(3, bindGroup53);
} catch {}
try {
device0.queue.writeBuffer(buffer69, 0, new DataView(new ArrayBuffer(87088)), 1260, 0);
} catch {}
let commandEncoder102 = device0.createCommandEncoder();
let textureView108 = texture42.createView({dimension: 'cube-array', format: 'eac-rg11unorm', baseArrayLayer: 6, arrayLayerCount: 6});
let textureView109 = texture26.createView({dimension: '2d-array'});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
computePassEncoder27.setBindGroup(0, bindGroup62, [0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer71, 0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer17, 'uint16', 42, 11);
} catch {}
try {
commandEncoder90.copyTextureToTexture({
  texture: texture68,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture107,
  mipLevel: 1,
  origin: {x: 7, y: 8, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2345, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 32, y: 4 },
  flipY: false,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 175, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 12, height: 36, depthOrArrayLayers: 0});
} catch {}
let buffer82 = device0.createBuffer({size: 200, usage: GPUBufferUsage.INDEX});
let textureView110 = texture10.createView({dimension: '2d-array', format: 'r16uint', mipLevelCount: 1});
let externalTexture16 = device0.importExternalTexture({source: videoFrame13});
try {
renderPassEncoder7.draw(82, 0, 660_140_207);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer77, 24);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup31, new Uint32Array(114), 14, 0);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer80, 'uint16', 2, 9);
} catch {}
try {
  await promise11;
} catch {}
let offscreenCanvas4 = new OffscreenCanvas(96, 6);
let bindGroup67 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 52, resource: {buffer: buffer40}}]});
let commandEncoder103 = device0.createCommandEncoder({});
let texture119 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView111 = texture29.createView({dimension: '2d-array', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder26.end();
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup31, new Uint32Array(2002), 306, 0);
} catch {}
try {
renderPassEncoder12.draw(254, 14, 2_036_769_097, 3);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer77, 'uint16', 128, 95);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 4, new DataView(new ArrayBuffer(1024)), 47, 0);
} catch {}
let bindGroup68 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 2, resource: {buffer: buffer74, offset: 0, size: 12}}],
});
let buffer83 = device0.createBuffer({
  size: 64,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture120 = device0.createTexture({
  size: [180, 105, 1],
  mipLevelCount: 4,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let externalTexture17 = device0.importExternalTexture({source: videoFrame9, colorSpace: 'srgb'});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer72, 96); };
} catch {}
try {
computePassEncoder24.end();
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 11, 0, 441_298_837);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer10, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(6, buffer12, 8, 11);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer17, 'uint32', 12, 8);
} catch {}
let buffer84 = device0.createBuffer({size: 252, usage: GPUBufferUsage.INDEX});
let commandEncoder104 = device0.createCommandEncoder({});
try {
renderPassEncoder7.drawIndexedIndirect(buffer72, 60);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer18, 'uint32', 0, 14);
} catch {}
try {
commandEncoder54.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 500 */
  offset: 500,
  bytesPerRow: 2048,
  buffer: buffer72,
}, {
  texture: texture78,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder14.insertDebugMarker('\u411b');
} catch {}
try {
renderPassEncoder20.insertDebugMarker('\u07db');
} catch {}
let texture121 = device0.createTexture({
  size: [90, 52, 174],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView112 = texture60.createView({mipLevelCount: 1});
let computePassEncoder31 = commandEncoder59.beginComputePass();
try {
renderPassEncoder12.draw(175, 8, 5_731_849, 4);
} catch {}
try {
renderPassEncoder12.drawIndexed(4, 8, 0, 751_198_308, 1);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer38, 4);
} catch {}
let gpuCanvasContext5 = offscreenCanvas4.getContext('webgpu');
try {
renderPassEncoder10.label = '\u8294\u34a5\u092a\u29ce\u0497\u17bf\ue4b1';
} catch {}
try {
computePassEncoder31.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup67, new Uint32Array(386), 0, 1);
} catch {}
try {
renderPassEncoder12.drawIndexed(4, 13, 0, -1_758_250_689, 4);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline7);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(28); };
} catch {}
let imageData13 = new ImageData(8, 12);
try {
adapter0.label = '\u43aa\u{1ff6d}\u3082\u4876\u{1f6dc}';
} catch {}
let texture122 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView113 = texture47.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder12.draw(266, 4, 1_168_544_596, 3);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer21, 12);
} catch {}
let textureView114 = texture93.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder27.setBindGroup(2, bindGroup39, new Uint32Array(237), 0, 1);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(0, buffer11, 4);
} catch {}
let arrayBuffer5 = buffer53.getMappedRange(32, 0);
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture123 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 24},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView115 = texture65.createView({});
try {
renderPassEncoder26.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(662);
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 0, -2_086_510_754);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer0, 'uint32', 0, 2);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer74, 0, 87);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let bindGroup69 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 3, resource: textureView79},
    {binding: 11, resource: textureView38},
    {binding: 5, resource: textureView108},
    {binding: 407, resource: {buffer: buffer10}},
    {binding: 0, resource: {buffer: buffer40}},
    {binding: 8, resource: {buffer: buffer34}},
  ],
});
let externalTexture18 = device0.importExternalTexture({source: videoFrame12});
try {
computePassEncoder28.setBindGroup(0, bindGroup16, new Uint32Array(316), 12, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder12.drawIndexed(4, 5, 0, 194_119_535, 12);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(2, buffer37, 0);
} catch {}
try {
commandEncoder79.resolveQuerySet(querySet1, 20, 1, buffer83, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 72, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(6).fill(98), /* required buffer size: 6 */
{offset: 6}, {width: 88, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline17 = await promise9;
document.body.append(canvas0);
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpteRp431', transfer: 'pq'} });
let commandEncoder105 = device0.createCommandEncoder({});
try {
computePassEncoder31.setBindGroup(0, bindGroup26, new Uint32Array(1227), 190, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder7.draw(180, 0, 1_165_987_499, 0);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer77, 28);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline9);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2345, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 276, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let texture124 = device0.createTexture({
  size: [45],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture125 = device0.createTexture({
  size: [408],
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroups(1, 2, 1); };
} catch {}
try {
renderPassEncoder7.draw(524, 0, 440_527_808);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer61, 44);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer77, 28);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer22, 0);
} catch {}
try {
device0.queue.submit([commandBuffer12]);
} catch {}
let commandEncoder106 = device0.createCommandEncoder();
let textureView116 = texture109.createView({format: 'r16uint'});
try {
computePassEncoder19.setBindGroup(1, bindGroup33);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer67, 0); };
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup11, new Uint32Array(32), 3, 0);
} catch {}
try {
renderPassEncoder12.draw(663, 20, 1_031_371_793, 3);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer77, 64);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer10, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer71, 'uint16', 8, 23);
} catch {}
let textureView117 = texture76.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder21.setBindGroup(1, bindGroup14, new Uint32Array(1181), 18, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup31, new Uint32Array(971), 83, 0);
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.drawIndexed(3, 0, 0, 45_762_489);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline9);
} catch {}
try {
  await shaderModule5.getCompilationInfo();
} catch {}
try {
buffer0.unmap();
} catch {}
let autogeneratedBindGroupLayout7 = pipeline12.getBindGroupLayout(0);
let buffer85 = device0.createBuffer({size: 1, usage: GPUBufferUsage.UNIFORM});
let textureView118 = texture92.createView({dimension: '2d-array'});
try {
computePassEncoder27.setBindGroup(1, bindGroup51, new Uint32Array(523), 70, 0);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup26);
} catch {}
try {
renderPassEncoder12.draw(147, 3, 599_233_372, 13);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 3, 1, -2_027_572_552);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer21, 20);
} catch {}
let promise12 = shaderModule3.getCompilationInfo();
try {
buffer35.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new Uint32Array(1376).map((_, i) => i * 4), 164, 0);
} catch {}
try {
computePassEncoder14.setBindGroup(1, bindGroup7);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer18, 0); };
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 0, 48_857_035);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(5, buffer72, 0, 13);
} catch {}
try {
device0.queue.writeBuffer(buffer57, 64, new Float64Array(3389).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/3384)), 344, 0);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas0);
let commandEncoder107 = device0.createCommandEncoder({});
let commandBuffer13 = commandEncoder46.finish();
let textureView119 = texture88.createView({dimension: '2d-array'});
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer39, 52); };
} catch {}
try {
renderPassEncoder12.draw(40, 22, 753_726_863, 1);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer71, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer32, 'uint16', 4, 9);
} catch {}
try {
device0.queue.submit([commandBuffer13]);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 20, new Float32Array(12737).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7815)), 6882, 0);
} catch {}
document.body.append(img0);
let commandEncoder108 = device0.createCommandEncoder({});
let textureView120 = texture108.createView({});
try {
renderPassEncoder12.draw(83, 7, 1_894_268_948, 2);
} catch {}
try {
renderPassEncoder7.drawIndexed(4, 0, 1, 813_020_466);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer21, 44);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
document.body.append(img0);
let bindGroup70 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 2, resource: {buffer: buffer34}}]});
let commandEncoder109 = device0.createCommandEncoder({});
let texture126 = device0.createTexture({
  size: {width: 1172, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder22.setBindGroup(1, bindGroup32);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup70, new Uint32Array(232), 54, 0);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
commandEncoder107.copyBufferToBuffer(buffer37, 44, buffer80, 24, 28);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let buffer86 = device0.createBuffer({size: 324, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder110 = device0.createCommandEncoder({});
try {
renderPassEncoder7.drawIndexed(2, 0, 0, 875_317_420);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer80, 'uint16', 8, 13);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(2, buffer13, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup15, new Uint32Array(1961), 354, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 24, new DataView(new ArrayBuffer(706)), 40, 32);
} catch {}
document.body.prepend(canvas0);
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 2, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {binding: 8, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 11, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {binding: 15, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 29,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 52,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 139,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 146,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
    {
      binding: 238,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 239,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 252,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 303,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 337,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 571,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let buffer87 = device0.createBuffer({
  size: 68,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
try {
computePassEncoder30.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder7.draw(111, 0, 397_138_086);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer87, 12);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer84, 'uint32', 176, 26);
} catch {}
try {
buffer53.unmap();
} catch {}
let pipeline18 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0xb40140ea},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{
  format: 'r16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex2',
    constants: {},
    buffers: [
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x4', offset: 0, shaderLocation: 9},
          {format: 'uint16x4', offset: 0, shaderLocation: 0},
          {format: 'unorm8x2', offset: 0, shaderLocation: 10},
          {format: 'uint8x2', offset: 0, shaderLocation: 15},
          {format: 'float32x3', offset: 0, shaderLocation: 3},
          {format: 'snorm8x2', offset: 18, shaderLocation: 5},
          {format: 'uint8x4', offset: 0, shaderLocation: 7},
          {format: 'float32x4', offset: 0, shaderLocation: 6},
          {format: 'uint8x4', offset: 0, shaderLocation: 11},
          {format: 'unorm16x4', offset: 0, shaderLocation: 2},
          {format: 'float32x4', offset: 0, shaderLocation: 12},
          {format: 'sint32x2', offset: 0, shaderLocation: 1},
          {format: 'unorm8x2', offset: 2, shaderLocation: 8},
          {format: 'uint16x4', offset: 0, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 256,
        attributes: [
          {format: 'uint16x4', offset: 64, shaderLocation: 13},
          {format: 'uint8x2', offset: 58, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-list', cullMode: 'back', unclippedDepth: true},
});
try {
gpuCanvasContext4.unconfigure();
} catch {}
document.body.prepend(canvas0);
let commandEncoder111 = device0.createCommandEncoder({});
let texture127 = device0.createTexture({
  size: {width: 372, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer61, 164); };
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer78, 0);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer34, 12);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer72, 'uint32', 116, 88);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline7);
} catch {}
let imageData14 = new ImageData(28, 200);
let autogeneratedBindGroupLayout8 = pipeline5.getBindGroupLayout(0);
let commandBuffer14 = commandEncoder61.finish();
let textureView121 = texture84.createView({mipLevelCount: 1});
try {
computePassEncoder30.setBindGroup(1, bindGroup22);
} catch {}
try {
renderPassEncoder12.draw(373, 18, 1_095_237_254);
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 0, 324_266_685);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer29, 152);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer86, 'uint16', 2, 11);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline18);
} catch {}
try {
commandEncoder28.copyBufferToBuffer(buffer10, 4, buffer39, 88, 12);
} catch {}
let bindGroup71 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 3, resource: {buffer: buffer22}}, {binding: 2, resource: {buffer: buffer61}}],
});
try {
renderPassEncoder12.drawIndexed(3, 3, 0, 627_261_811, 26);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer40, 68);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer40, 28);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup19);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline10);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
buffer13.unmap();
} catch {}
try {
  await promise12;
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

enable f16;

@group(0) @binding(2) var<storage, read_write> buffer88: array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 6>, 1>, 1>>;

var<private> vp12: FragmentInput10 = FragmentInput10(vec2h(33614.8, 103.9));

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

@group(0) @binding(0) var st18: texture_storage_3d<r32float, read_write>;

var<private> vp13: FragmentInput11 = FragmentInput11();

@id(46347) override override10: f32;

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

@id(37923) override override9: i32 = 736037375;

var<private> vp8 = modf(vec3h(29221.1, 604.1, 7794.2));

var<private> vp6: FragmentInput10 = FragmentInput10(vec2h(2915.0, 21367.4));

struct FragmentInput11 {
  @location(10) @interpolate(perspective, centroid) location_10: f32,
  @builtin(sample_mask) sample_mask: u32,
}

var<private> vp7 = frexp(f16(1863.4));

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

struct FragmentOutput4 {
  @location(1) location_1: i32,
  @location(0) @interpolate(flat) location_0: u32,
}

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

struct VertexInput15 {
  @location(15) location_15: vec4i,
  @location(9) location_9: vec4h,
  @location(8) location_8: f32,
  @location(7) location_7: vec2u,
}

struct VertexInput16 {
  @location(0) @interpolate(flat) location_0: vec2i,
  @location(5) @interpolate(flat, centroid) location_5: i32,
  @location(4) location_4: vec2h,
  @location(11) @interpolate(flat) location_11: vec2i,
}

struct FragmentInput10 {
  @location(1) @interpolate(perspective, first) location_1: vec2h,
}

var<private> vp9: FragmentInput11 = FragmentInput11();

struct VertexOutput3 {
  @builtin(position) position: vec4f,
  @location(11) @interpolate(flat, centroid) location_11: vec2u,
  @location(13) location_13: u32,
}

var<private> vp4: array<vec2f, 1> = array(vec2f(0.05886e-32, 0.02400));

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

var<private> vp10: vec2u = vec2u(45300660, 157135398);

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

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

var<private> vp5: array<FragmentInput10, 4> = array<FragmentInput10, 4>();

@id(59484) override override11: u32;

/* zero global variables used */
@vertex
fn vertex3(a0: VertexInput15, a1: VertexInput16) -> VertexOutput3 {
  var out: VertexOutput3;
  out.position += vec4f(vp5[3].location_1.rrgr.ggrr.yyzy.raaa.xxxy.abbb.xzzz);
  return out;
}

/* used global variables: st18 */
@fragment
fn fragment4(@location(9) @interpolate(linear) location_9: vec4f, @location(4) location_4: i32, a2: FragmentInput10, a3: FragmentInput11, @builtin(position) position: vec4f) -> FragmentOutput4 {
  var out: FragmentOutput4;
  if bool(max(vec4h(unconst_f16(1509.3), unconst_f16(10613.2), unconst_f16(12742.8), unconst_f16(1762.6)), vec4h((vec2<bool>(unconst_bool(false), unconst_bool(false)) == vec2<bool>(position.ar.xx.xx)).rrrg.gara))[3]) {
  let vf44: vec2f = (unpack2x16float(vp13.sample_mask) + vec2f(unconst_f32(0.3606), unconst_f32(0.1762)));
  var vf45: f32 = position[unconst_u32(707885701)];
  let ptr22: ptr<private, u32> = &vp9.sample_mask;
  let ptr23: ptr<function, f32> = &vf45;
}
  var vf46: f16 = a2.location_1[pack4xI8(vec4i(unconst_i32(-456746020), unconst_i32(1330613222), unconst_i32(11293367), unconst_i32(118210522)))];
  textureStore(st18, vec3i(unconst_i32(-222342323), unconst_i32(347456403), unconst_i32(21799862)), vec4f(vec4f(unconst_f32(0.05634e-17), unconst_f32(0.1155e-11), unconst_f32(0.2340e7), unconst_f32(-0.4088))));
  let ptr24: ptr<private, f32> = &vp13.location_10;
  return out;
  _ = st18;
}

/* used global variables: buffer88 */
@compute @workgroup_size(4, 1, 2)
fn compute4() {
  vp7.fract += (*&buffer88)[unconst_u32(1030229663)][0][0][5][unconst_u32(39040135)][unconst_u32(1005000020)][0][0];
  let ptr25: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer88[arrayLength(&buffer88)][0][0][5][unconst_u32(750259891)][unconst_u32(231405334)];
  vp9.sample_mask *= u32(buffer88[arrayLength(&buffer88)][0][0][5][0][0][0][0]);
  let ptr26: ptr<storage, f16, read_write> = &buffer88[unconst_u32(507125537)][0][0][5][0][0][0][0];
  vp5[u32(buffer88[arrayLength(&buffer88)][0][unconst_u32(1091163838)][unconst_u32(358085754)][unconst_u32(35447298)][0][u32(buffer88[arrayLength(&buffer88)][0][0][u32((*&buffer88)[arrayLength(&(*&buffer88))][0][unconst_u32(469654704)][5][unconst_u32(186171759)][unconst_u32(1513164119)][0][0])][0][0][unconst_u32(678105696)][0])][unconst_u32(355927460)])].location_1 -= vec2h((*&buffer88)[unconst_u32(662634570)][0][0][5][unconst_u32(72223247)][unconst_u32(287228988)][0][0]);
  vp11 = bool(buffer88[unconst_u32(127331616)][unconst_u32(1423654610)][0][5][unconst_u32(14217139)][0][0][0]);
  let ptr27: ptr<storage, f16, read_write> = &buffer88[arrayLength(&buffer88)][unconst_u32(182363371)][0][5][unconst_u32(193291251)][unconst_u32(2278159948)][0][0];
  {
  vp12.location_1 *= vec2h(buffer88[arrayLength(&buffer88)][0][unconst_u32(511057891)][unconst_u32(474670699)][0][unconst_u32(461565315)][0][unconst_u32(1074693507)]);
  _ = buffer88;
}
  _ = buffer88;
}`,
});
let buffer92 = device0.createBuffer({size: 264, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let texture128 = device0.createTexture({size: [816, 1, 1], format: 'r16uint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder9.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer32, 'uint16', 4, 5);
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 360, height: 210, depthOrArrayLayers: 1}
*/
{
  source: videoFrame15,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture88,
  mipLevel: 0,
  origin: {x: 5, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup72 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 2, resource: {buffer: buffer28}}]});
let commandEncoder112 = device0.createCommandEncoder({});
try {
computePassEncoder16.setBindGroup(1, bindGroup53);
} catch {}
try {
renderPassEncoder7.draw(33, 0, 434_386_529);
} catch {}
try {
renderBundleEncoder25.setBindGroup(1, bindGroup17, new Uint32Array(870), 614, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 24, new DataView(new ArrayBuffer(173480)), 6048, 0);
} catch {}
let pipeline19 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4}});
let commandEncoder113 = device0.createCommandEncoder({});
let textureView122 = texture37.createView({dimension: '2d-array'});
try {
computePassEncoder8.setBindGroup(2, bindGroup34, []);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(1187);
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.drawIndexed(4, 0, 0, -1_771_163_316);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer61, 96);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer29, 48);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 20, new Uint32Array(6542).map((_, i) => i * 5), 548, 0);
} catch {}
let bindGroup73 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 3, resource: {buffer: buffer34}}, {binding: 2, resource: {buffer: buffer38}}],
});
let textureView123 = texture19.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder32 = commandEncoder48.beginComputePass();
let renderPassEncoder28 = commandEncoder108.beginRenderPass({
  colorAttachments: [{
  view: textureView34,
  depthSlice: 29,
  clearValue: { r: -881.6, g: -577.7, b: 771.7, a: 304.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder14.setBindGroup(0, bindGroup3);
} catch {}
try {
computePassEncoder10.setBindGroup(2, bindGroup54, new Uint32Array(68), 4, 0);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder7.draw(548, 0, 1_078_170_561);
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 1, 919_139_076);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer61, 16);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer87, 'uint16', 20, 7);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
document.body.append(img2);
let commandEncoder114 = device0.createCommandEncoder({});
let texture129 = device0.createTexture({size: [372, 1, 1], mipLevelCount: 4, format: 'r16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder23.setBindGroup(0, bindGroup60);
} catch {}
try {
computePassEncoder31.setBindGroup(1, bindGroup40, new Uint32Array(1269), 81, 0);
} catch {}
try {
computePassEncoder14.end();
} catch {}
try {
computePassEncoder15.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup71, new Uint32Array(928), 458, 0);
} catch {}
try {
commandEncoder36.copyTextureToBuffer({
  texture: texture101,
  mipLevel: 0,
  origin: {x: 217, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 204 */
  offset: 204,
  bytesPerRow: 26624,
  buffer: buffer57,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: videoFrame15,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 7, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
let recycledExplicitBindGroupLayout4 = pipeline16.getBindGroupLayout(1);
let buffer93 = device0.createBuffer({size: 192, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let texture130 = device0.createTexture({
  size: [45],
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
try {
computePassEncoder28.end();
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 0, 0, -1_243_516_619, 0);
} catch {}
try {
computePassEncoder21.insertDebugMarker('\u3d1e');
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(70); };
} catch {}
try {
  await promise14;
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout4,
  entries: [
    {binding: 90, resource: textureView43},
    {binding: 3, resource: {buffer: buffer64}},
    {binding: 1, resource: externalTexture1},
    {binding: 2, resource: {buffer: buffer10, size: 16}},
    {binding: 0, resource: textureView1},
  ],
});
let texture131 = device0.createTexture({
  size: {width: 180, height: 105, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
renderPassEncoder20.setBindGroup(0, bindGroup25, new Uint32Array(3103), 425, 0);
} catch {}
try {
renderPassEncoder7.draw(206, 0, 813_133_443);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer61, 48);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(6, buffer11);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let texture132 = device0.createTexture({
  size: [2976, 12, 1],
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'astc-12x12-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView124 = texture50.createView({});
try {
computePassEncoder12.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup32, new Uint32Array(4262), 804, 0);
} catch {}
try {
commandEncoder9.copyBufferToBuffer(buffer63, 8, buffer45, 16, 8);
} catch {}
let texture133 = device0.createTexture({
  size: [102, 1, 20],
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView125 = texture107.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6});
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder20.draw(181, 0, 1_160_933_386);
} catch {}
try {
renderPassEncoder20.drawIndexed(2, 0, 0, 72_602_538);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer61, 80);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(1, buffer12);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer94 = device0.createBuffer({size: 144, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder115 = device0.createCommandEncoder();
let texture134 = device0.createTexture({
  label: '\u0bca\u26f5',
  size: [204],
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture19 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
renderPassEncoder20.draw(64, 0, 478_761_807);
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 2, 0, 101_363_063, 9);
} catch {}
try {
renderPassEncoder20.drawIndexedIndirect(buffer10, 0);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(5, buffer37);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline10);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2345, height: 48, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 6, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder116 = device0.createCommandEncoder();
let textureView126 = texture22.createView({dimension: '2d-array', baseMipLevel: 0});
let sampler20 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat'});
try {
computePassEncoder32.setBindGroup(3, bindGroup14, new Uint32Array(1909), 724, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder12.end();
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer21, 8);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline4);
} catch {}
let pipeline20 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment3',
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule6,
    buffers: [
      {
        arrayStride: 44,
        attributes: [
          {format: 'sint16x4', offset: 16, shaderLocation: 5},
          {format: 'sint16x2', offset: 24, shaderLocation: 0},
          {format: 'uint16x2', offset: 0, shaderLocation: 7},
          {format: 'unorm8x4', offset: 20, shaderLocation: 9},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 4},
          {format: 'sint32', offset: 4, shaderLocation: 11},
          {format: 'sint8x2', offset: 0, shaderLocation: 15},
          {format: 'float32x2', offset: 0, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'none', unclippedDepth: true},
});
let commandEncoder117 = device0.createCommandEncoder({});
let computePassEncoder33 = commandEncoder100.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer39, 28);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer72, 100);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer84, 'uint16', 28, 1);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer92, 'uint16', 8, 5);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(0, buffer12, 0, 4);
} catch {}
let bindGroup75 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 3, resource: {buffer: buffer1}}, {binding: 2, resource: {buffer: buffer1}}],
});
let commandBuffer15 = commandEncoder36.finish();
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer71, 12); };
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup13);
} catch {}
try {
commandEncoder47.copyTextureToTexture({
  texture: texture104,
  mipLevel: 0,
  origin: {x: 19, y: 1, z: 6},
  aspect: 'all',
},
{
  texture: texture65,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
},
{width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(img0);
try {
{ clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder31.end();
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 8, 0, -2_126_496_319, 4);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer78, 4);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer93, 'uint16', 16, 51);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline20);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await promise13;
} catch {}
let texture135 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder33.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer78, 8);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer80, 'uint16', 12, 11);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup63, new Uint32Array(217), 43, 0);
} catch {}
let commandEncoder118 = device0.createCommandEncoder({});
try {
computePassEncoder17.setBindGroup(2, bindGroup36, new Uint32Array(162), 12, 0);
} catch {}
try {
computePassEncoder30.end();
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer72, 124);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer30, 56, 32);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer17, 'uint16', 18, 12);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let pipeline21 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  fragment: {module: shaderModule5, entryPoint: 'fragment3', targets: [{format: 'r16uint', writeMask: 0}]},
  vertex: {
    module: shaderModule6,
    constants: {},
    buffers: [
      {
        arrayStride: 84,
        attributes: [
          {format: 'sint32x3', offset: 24, shaderLocation: 0},
          {format: 'sint16x4', offset: 0, shaderLocation: 15},
          {format: 'sint32x4', offset: 4, shaderLocation: 11},
          {format: 'uint32x2', offset: 0, shaderLocation: 7},
          {format: 'unorm8x2', offset: 20, shaderLocation: 4},
          {format: 'sint32', offset: 4, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 32, shaderLocation: 8},
          {format: 'unorm16x2', offset: 12, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', unclippedDepth: true},
});
let imageBitmap1 = await createImageBitmap(videoFrame2);
let commandEncoder119 = device0.createCommandEncoder();
let texture136 = device0.createTexture({size: [45], dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView127 = texture44.createView({dimension: '2d-array'});
let renderPassEncoder29 = commandEncoder65.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  depthSlice: 70,
  clearValue: { r: -468.4, g: -988.7, b: -261.7, a: 9.586, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 152103105,
});
try {
renderPassEncoder28.setBindGroup(2, bindGroup43, new Uint32Array(220), 20, 0);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer61, 64);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer39, 136);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline7);
} catch {}
let textureView128 = texture94.createView({mipLevelCount: 1});
let computePassEncoder34 = commandEncoder28.beginComputePass();
let renderPassEncoder30 = commandEncoder13.beginRenderPass({
  colorAttachments: [{
  view: textureView47,
  depthSlice: 13,
  clearValue: { r: -631.2, g: 379.1, b: 40.84, a: -191.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 154165360,
});
try {
renderPassEncoder20.drawIndexed(2, 0, 1, 216_041_471);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer39, 20);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer30, 0, 11);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup13, new Uint32Array(682), 225, 0);
} catch {}
let pipeline22 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute3'}});
let buffer95 = device0.createBuffer({size: 17, usage: GPUBufferUsage.VERTEX});
let commandBuffer16 = commandEncoder26.finish();
let texture137 = device0.createTexture({
  size: [293, 6, 17],
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler21 = device0.createSampler({
  addressModeV: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 44.40,
  lodMaxClamp: 65.54,
});
try {
renderPassEncoder12.draw(64, 3, 598_940_569, 3);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer78, 20);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup64, []);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup63, new Uint32Array(2460), 359, 0);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(3, buffer51, 24, 24);
} catch {}
try {
device0.queue.submit([commandBuffer14]);
} catch {}
let bindGroup76 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: externalTexture1},
    {binding: 2, resource: {buffer: buffer34, size: 128}},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer61}},
    {binding: 0, resource: textureView1},
  ],
});
let commandEncoder120 = device0.createCommandEncoder({});
let commandBuffer17 = commandEncoder88.finish({});
try {
renderPassEncoder15.drawIndexed(3, 0, 0, 53_289_829);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer29, 32);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup23);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer56, 24);
} catch {}
try {
buffer68.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer17, commandBuffer15]);
} catch {}
try {
computePassEncoder9.setBindGroup(1, bindGroup34);
} catch {}
try {
renderPassEncoder26.draw(35, 132, 21, 2_245_527_063);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer78, 16);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer51);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer75, 'uint32', 16, 2);
} catch {}
try {
commandEncoder9.pushDebugGroup('\u9522');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup77 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 2, resource: {buffer: buffer87}}, {binding: 3, resource: {buffer: buffer1}}],
});
let commandEncoder121 = device0.createCommandEncoder({});
let commandBuffer18 = commandEncoder74.finish();
try {
computePassEncoder34.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup11);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer13, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture112,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(66).fill(212), /* required buffer size: 66 */
{offset: 66, bytesPerRow: 82}, {width: 36, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 3, resource: {buffer: buffer34}}, {binding: 2, resource: {buffer: buffer10, size: 16}}],
});
try {
computePassEncoder33.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder3.draw(111, 0, 962_490_143);
} catch {}
try {
renderPassEncoder20.drawIndexedIndirect(buffer62, 12);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(0, buffer51, 0, 42);
} catch {}
try {
commandEncoder73.copyBufferToBuffer(buffer73, 8, buffer10, 4, 0);
} catch {}
try {
device0.queue.submit([commandBuffer18]);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 16, new DataView(new ArrayBuffer(16980)), 398, 4);
} catch {}
let commandEncoder122 = device0.createCommandEncoder({});
let texture138 = device0.createTexture({
  size: {width: 2345},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler22 = device0.createSampler({label: '\u{1fb6f}\u3302\u0e70\u0978\u7d44\u30eb', addressModeU: 'repeat', lodMaxClamp: 98.29});
try {
computePassEncoder32.setBindGroup(1, bindGroup36, new Uint32Array(597), 75, 0);
} catch {}
try {
renderPassEncoder20.draw(132, 0, 993_995_782);
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 17, 0, 536_126_016);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline20);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup79 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 1, resource: externalTexture16},
    {binding: 90, resource: textureView57},
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer54}},
    {binding: 3, resource: {buffer: buffer61}},
  ],
});
try {
computePassEncoder34.setBindGroup(1, bindGroup34, new Uint32Array(3318), 295, 0);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer87, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup61);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup50, new Uint32Array(2794), 738, 0);
} catch {}
try {
renderBundleEncoder26.draw(0, 461, 0, 766_842_967);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline9);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 12, new Uint32Array(5992).map((_, i) => i * 10), 1722, 0);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(37); };
} catch {}
let recycledExplicitBindGroupLayout5 = pipeline0.getBindGroupLayout(1);
let commandBuffer19 = commandEncoder59.finish({});
let texture139 = device0.createTexture({size: {width: 180}, sampleCount: 1, dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_SRC});
let renderBundle6 = renderBundleEncoder26.finish({});
try {
renderPassEncoder22.setBindGroup(0, bindGroup79, new Uint32Array(1066), 83, 0);
} catch {}
try {
renderPassEncoder12.draw(182, 2, 1_268_900_722, 4);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer17, 'uint16', 22, 3);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup64, new Uint32Array(1464), 145, 0);
} catch {}
try {
renderBundleEncoder14.draw(6, 132, 3, 466_781_558);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer86, 'uint32', 12, 36);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline9);
} catch {}
try {
device0.queue.submit([commandBuffer19]);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup80 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 52, resource: {buffer: buffer1, size: 56}}],
});
let commandEncoder123 = device0.createCommandEncoder({});
let texture140 = device0.createTexture({
  size: {width: 744, height: 3, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView129 = texture82.createView({dimension: '2d', baseArrayLayer: 4});
try {
renderPassEncoder0.setBindGroup(0, bindGroup32);
} catch {}
try {
renderPassEncoder26.draw(88, 165, 96, 156_360_582);
} catch {}
try {
renderPassEncoder20.drawIndexedIndirect(buffer40, 56);
} catch {}
try {
commandEncoder9.popDebugGroup();
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer28, 40, new Uint32Array(1100).map((_, i) => i * 3), 119, 8);
} catch {}
let commandEncoder124 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({size: {width: 408}, dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder3.drawIndexed(26, 0, 19, 941_206_350);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer18, 8);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(1, buffer72);
} catch {}
try {
commandEncoder119.clearBuffer(buffer39);
} catch {}
let pipeline23 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x3afaecef},
  fragment: {module: shaderModule5, entryPoint: 'fragment3', constants: {}, targets: [{format: 'r16uint'}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 48,
        attributes: [
          {format: 'unorm8x4', offset: 0, shaderLocation: 6},
          {format: 'unorm16x2', offset: 0, shaderLocation: 2},
          {format: 'float16x4', offset: 4, shaderLocation: 9},
          {format: 'snorm16x2', offset: 4, shaderLocation: 11},
          {format: 'snorm8x4', offset: 4, shaderLocation: 7},
          {format: 'uint32x2', offset: 4, shaderLocation: 12},
          {format: 'sint8x4', offset: 16, shaderLocation: 3},
          {format: 'float32', offset: 0, shaderLocation: 8},
          {format: 'float32x3', offset: 4, shaderLocation: 0},
          {format: 'snorm16x4', offset: 16, shaderLocation: 5},
          {format: 'uint16x2', offset: 12, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 0, shaderLocation: 10},
          {format: 'sint32x3', offset: 0, shaderLocation: 1},
          {format: 'sint8x2', offset: 0, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 15},
          {format: 'uint32', offset: 0, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
await gc();
let commandEncoder125 = device0.createCommandEncoder({label: '\u0d35\u{1f99a}\uf7e4\u{1fe3f}\u11e7\uf2ee'});
let textureView130 = texture24.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 8});
let sampler23 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 74.82,
  maxAnisotropy: 8,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup35, [0]);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup1, new Uint32Array(6566), 732, 0);
} catch {}
try {
renderPassEncoder12.draw(204, 8, 487_511_761, 6);
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 3, 1, -1_571_498_824, 2);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline21);
} catch {}
document.body.prepend(canvas0);
let bindGroup81 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 2, resource: {buffer: buffer38, offset: 0}}],
});
let commandBuffer20 = commandEncoder83.finish();
try {
computePassEncoder29.setBindGroup(2, bindGroup55, new Uint32Array(1887), 241, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup60);
} catch {}
try {
renderPassEncoder20.drawIndexed(3, 0, 0, 119_405_755);
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'bt709'} });
let buffer96 = device0.createBuffer({size: 240, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let texture142 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 647},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder16.setBindGroup(3, bindGroup80, new Uint32Array(205), 18, 1);
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder3.drawIndexed(13, 0, 3, 62_516_054);
} catch {}
try {
renderBundleEncoder2.draw(0, 307, 0, 281_644_968);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture63,
  mipLevel: 0,
  origin: {x: 31, y: 2, z: 7},
  aspect: 'all',
}, new Uint8Array(808).fill(173), /* required buffer size: 808 */
{offset: 67, bytesPerRow: 191}, {width: 84, height: 4, depthOrArrayLayers: 1});
} catch {}
let bindGroup82 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 52, resource: {buffer: buffer34}}]});
let commandEncoder126 = device0.createCommandEncoder({});
try {
renderPassEncoder3.draw(177, 0, 364_500_591);
} catch {}
try {
renderPassEncoder3.drawIndexed(34, 0, 5, 292_366_289);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer10, 16);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer95);
} catch {}
try {
renderBundleEncoder14.drawIndexedIndirect(buffer40, 16);
} catch {}
try {
device0.queue.writeBuffer(buffer59, 4, new Uint16Array(638).map((_, i) => i + 3), 58, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 75},
  aspect: 'all',
}, new Uint8Array(623_597).fill(44), /* required buffer size: 623_597 */
{offset: 32, bytesPerRow: 31, rowsPerImage: 135}, {width: 14, height: 0, depthOrArrayLayers: 150});
} catch {}
let offscreenCanvas5 = new OffscreenCanvas(23, 195);
let bindGroup83 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout1,
  entries: [
    {binding: 2, resource: {buffer: buffer28}},
    {binding: 0, resource: textureView0},
    {binding: 3, resource: {buffer: buffer1, size: 76}},
    {binding: 90, resource: textureView43},
    {binding: 1, resource: externalTexture13},
  ],
});
let texture143 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder21.setBindGroup(0, bindGroup52);
} catch {}
try {
renderPassEncoder20.end();
} catch {}
try {
renderPassEncoder15.drawIndirect(buffer21, 8);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer11, 'uint32', 1_116, 1_020);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 16, new Float32Array(5401).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.08319)), 613, 0);
} catch {}
let bindGroup84 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 0, resource: textureView1},
    {binding: 90, resource: textureView8},
    {binding: 3, resource: {buffer: buffer40}},
    {binding: 1, resource: externalTexture18},
    {binding: 2, resource: {buffer: buffer64}},
  ],
});
let buffer97 = device0.createBuffer({
  size: 1139,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView131 = texture115.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder29.setBindGroup(0, bindGroup41, new Uint32Array(2001), 92, 0);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer71, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup32);
} catch {}
try {
commandEncoder92.resolveQuerySet(querySet1, 84, 1, buffer19, 0);
} catch {}
try {
device0.queue.submit([commandBuffer20]);
} catch {}
let renderPassEncoder31 = commandEncoder97.beginRenderPass({
  colorAttachments: [{
  view: textureView54,
  clearValue: { r: 907.8, g: -534.7, b: 786.0, a: -485.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
let renderBundle7 = renderBundleEncoder14.finish({});
try {
computePassEncoder33.setBindGroup(1, bindGroup13, new Uint32Array(3571), 35, 0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 8, 0, -1_470_519_013, 1);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer40, 40);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer18, 4);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer56);
} catch {}
try {
renderBundleEncoder2.drawIndexedIndirect(buffer72, 356);
} catch {}
let gpuCanvasContext6 = offscreenCanvas5.getContext('webgpu');
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(77); };
} catch {}
let imageBitmap2 = await createImageBitmap(videoFrame15);
let bindGroup85 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 1, resource: externalTexture1},
    {binding: 2, resource: {buffer: buffer54}},
    {binding: 0, resource: textureView51},
    {binding: 3, resource: {buffer: buffer54}},
    {binding: 90, resource: textureView43},
  ],
});
let buffer98 = device0.createBuffer({size: 488, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let externalTexture20 = device0.importExternalTexture({source: videoFrame13});
try {
renderPassEncoder15.end();
} catch {}
try {
renderPassEncoder16.drawIndexed(3, 0, 1, -2_012_725_679);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline21);
} catch {}
try {
renderBundleEncoder21.setBindGroup(1, bindGroup22);
} catch {}
try {
renderBundleEncoder2.draw(0, 70, 0, 1_086_280_642);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer72, 136);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline20);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 8, new Float32Array(6182).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.377)), 91, 0);
} catch {}
try {
adapter0.label = '\u0efe\u{1fd28}\u3f6c\u047d\u87f4\u06fd\ued5b\u46b1';
} catch {}
let commandEncoder127 = device0.createCommandEncoder();
let commandBuffer21 = commandEncoder14.finish();
try {
renderPassEncoder22.drawIndexed(3, 1, 0, 370_839_882, 2);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer34, 16);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer77, 'uint16', 2, 170);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(0, buffer72, 236, 2);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer18, 0);
} catch {}
try {
commandEncoder66.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture21,
  mipLevel: 0,
  origin: {x: 18, y: 10, z: 0},
  aspect: 'all',
},
{width: 6, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer21]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {binding: 10, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 230,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let bindGroup86 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 3, resource: {buffer: buffer64}}, {binding: 2, resource: {buffer: buffer97, size: 228}}],
});
let buffer99 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let commandEncoder128 = device0.createCommandEncoder();
let textureView132 = texture58.createView({});
try {
computePassEncoder25.setBindGroup(1, bindGroup3, new Uint32Array(969), 77, 0);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer62, 16);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer84, 'uint16', 102, 7);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer97, 0, 14);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup15, []);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer21, 4);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline23);
} catch {}
try {
device0.queue.writeBuffer(buffer69, 0, new DataView(new ArrayBuffer(84264)), 1710, 0);
} catch {}
let buffer100 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
try {
renderPassEncoder3.drawIndexed(3, 0, 0, -1_871_292_256);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup61);
} catch {}
try {
renderBundleEncoder2.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline9);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer101 = device0.createBuffer({size: 204, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder26.draw(30, 64, 17, 694_118_653);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer87, 4);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer72, 'uint16', 118, 106);
} catch {}
try {
renderBundleEncoder17.setBindGroup(1, bindGroup22);
} catch {}
try {
commandEncoder106.resolveQuerySet(querySet2, 1, 1, buffer83, 0);
} catch {}
let bindGroup87 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 2, resource: {buffer: buffer92}}]});
let buffer102 = device0.createBuffer({size: 84, usage: GPUBufferUsage.INDIRECT});
let commandEncoder129 = device0.createCommandEncoder();
let commandBuffer22 = commandEncoder50.finish();
try {
computePassEncoder8.setBindGroup(0, bindGroup39, [0]);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer61, 16);
} catch {}
let pipeline24 = await device0.createRenderPipelineAsync({
  label: '\u9158\u9326\u{1f989}\u0831\u8e91',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule6,
  constants: {},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 1036,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 396, shaderLocation: 7},
          {format: 'unorm8x4', offset: 128, shaderLocation: 1},
          {format: 'sint32x4', offset: 44, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip'},
});
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'iec61966-2-1'} });
let commandEncoder130 = device0.createCommandEncoder({});
let textureView133 = texture49.createView({dimension: '2d-array'});
try {
computePassEncoder25.setBindGroup(0, bindGroup7, new Uint32Array(1139), 336, 0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer101, 148);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer0, 0);
} catch {}
try {
renderBundleEncoder2.drawIndexedIndirect(buffer18, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
buffer13.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer83, 4, new Uint32Array(3663).map((_, i) => i * 4), 133, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 11}
*/
{
  source: imageData4,
  origin: { x: 2, y: 12 },
  flipY: false,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 8, y: 5, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let texture144 = device0.createTexture({
  size: {width: 816, height: 1, depthOrArrayLayers: 834},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
{ clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroupsIndirect(buffer71, 0); };
} catch {}
try {
renderPassEncoder6.setVertexBuffer(6, buffer95, 4, 1);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup33);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup64, new Uint32Array(2435), 51, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer72, 'uint32', 12, 179);
} catch {}
try {
device0.queue.writeBuffer(buffer96, 76, new Float32Array(1336).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.070)), 425, 0);
} catch {}
document.body.append(img0);
let commandEncoder131 = device0.createCommandEncoder({});
let textureView134 = texture15.createView({dimension: '2d'});
let computePassEncoder35 = commandEncoder66.beginComputePass();
try {
computePassEncoder34.setBindGroup(0, bindGroup40, new Uint32Array(1348), 15, 0);
} catch {}
try {
renderPassEncoder26.draw(15, 53, 134, 223_815_187);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer101, 4);
} catch {}
try {
renderBundleEncoder2.draw(0, 95, 0, 154_726_675);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
document.body.append(canvas0);
let commandEncoder132 = device0.createCommandEncoder({});
let texture145 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder35.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle1]);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer34, 4);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer71, 'uint32', 8, 15);
} catch {}
try {
device0.queue.submit([commandBuffer22]);
} catch {}
try {
device0.queue.writeBuffer(buffer97, 476, new Float64Array(14085).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/14084)), 471, 40);
} catch {}
document.body.prepend(canvas0);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture146 = device0.createTexture({
  size: [586, 12, 31],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder12.drawIndexed(3, 5, 1, 345_729_201, 1);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer10, 32);
} catch {}
try {
renderBundleEncoder2.draw(0, 7, 0, 657_862_824);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer71, 'uint16', 8, 19);
} catch {}
try {
commandEncoder90.copyBufferToTexture({
  /* bytesInLastRow: 9040 widthInBlocks: 565 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 6640 */
  offset: 6640,
  bytesPerRow: 20992,
  buffer: buffer2,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 596, y: 5, z: 0},
  aspect: 'all',
}, {width: 565, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder10.copyTextureToTexture({
  texture: texture120,
  mipLevel: 1,
  origin: {x: 27, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture59,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
},
{width: 20, height: 6, depthOrArrayLayers: 0});
} catch {}
await gc();
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteSt4281', transfer: 'log'} });
try {
{ clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer62, 8);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer75, 'uint16', 4, 0);
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1636 */
  offset: 1636,
  bytesPerRow: 29696,
  buffer: buffer2,
}, {
  texture: texture124,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer17, 32, new BigInt64Array(16908).map((_, i) => BigInt(i - 0)), 1871, 0);
} catch {}
let buffer103 = device0.createBuffer({size: 76, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
try {
computePassEncoder35.setBindGroup(0, bindGroup10, new Uint32Array(1664), 321, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer71, 8); };
} catch {}
try {
renderBundleEncoder2.draw(0, 218, 0, 58_230_337);
} catch {}
try {
commandEncoder72.copyBufferToBuffer(buffer87, 12, buffer11, 64, 0);
} catch {}
try {
renderBundleEncoder13.insertDebugMarker('\ued13');
} catch {}
let buffer104 = device0.createBuffer({size: 192, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder133 = device0.createCommandEncoder({});
try {
computePassEncoder33.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder22.drawIndexed(11, 2, 0, 390_465_581);
} catch {}
try {
renderBundleEncoder18.setBindGroup(0, bindGroup29, new Uint32Array(3783), 120, 0);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline6);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 7, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 18, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 38,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 84,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 159,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 181,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 187,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 202,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 244,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer105 = device0.createBuffer({size: 36, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder134 = device0.createCommandEncoder();
let texture147 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 29},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundle8 = renderBundleEncoder2.finish({});
try {
renderBundleEncoder12.setBindGroup(0, bindGroup83);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup45, new Uint32Array(477), 80, 1);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer71, 'uint16', 20, 6);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let recycledExplicitBindGroupLayout6 = pipeline17.getBindGroupLayout(1);
let buffer106 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView135 = texture24.createView({mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 2});
let texture148 = device0.createTexture({
  size: {width: 372},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView136 = texture123.createView({mipLevelCount: 1});
try {
computePassEncoder16.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder12.draw(415, 3, 92_766_266, 2);
} catch {}
try {
renderPassEncoder26.drawIndexed(3, 60, 0, -1_858_975_916, 589_542_685);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer32, 'uint32', 0, 18);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(3, buffer12, 0, 2);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup2);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer72, 'uint32', 140, 340);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline21);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(3, buffer13, 0, 2);
} catch {}
document.body.prepend(canvas0);
try {
globalThis.someLabel = externalTexture3.label;
} catch {}
let commandEncoder135 = device0.createCommandEncoder({});
try {
computePassEncoder25.setBindGroup(2, bindGroup58, new Uint32Array(3521), 505, 0);
} catch {}
try {
computePassEncoder6.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder16.drawIndexed(3, 0, 0, 333_146_388);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup56, new Uint32Array(1135), 12, 0);
} catch {}
try {
renderBundleEncoder18.draw(1, 179, 0, 1_074_446_596);
} catch {}
try {
renderBundleEncoder18.drawIndexedIndirect(buffer77, 16);
} catch {}
try {
computePassEncoder15.insertDebugMarker('\u067b');
} catch {}
try {
device0.queue.writeBuffer(buffer59, 0, new DataView(new Uint8Array(728).map((_, i) => i).buffer), 88, 8);
} catch {}
offscreenCanvas3.width = 207;
await gc();
let textureView137 = texture64.createView({dimension: '2d-array', format: 'r16uint', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer101, 48); };
} catch {}
try {
computePassEncoder34.end();
} catch {}
try {
computePassEncoder19.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder26.draw(16, 5, 9, 2_165_279_379);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer86, 0);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline24);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer34, 112, new DataView(new ArrayBuffer(1484)), 151, 8);
} catch {}
let imageData15 = new ImageData(120, 32);
let bindGroup88 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 0, resource: {buffer: buffer76, size: 132}},
    {binding: 8, resource: {buffer: buffer97, size: 400}},
    {binding: 407, resource: {buffer: buffer92}},
    {binding: 11, resource: textureView7},
    {binding: 5, resource: textureView108},
    {binding: 3, resource: textureView79},
  ],
});
try {
computePassEncoder9.setBindGroup(3, bindGroup31, new Uint32Array(2515), 133, 0);
} catch {}
try {
renderPassEncoder12.draw(612, 8, 1_073_454_618);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer72, 36);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer84, 'uint32', 4, 54);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer97, 116, 132);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer0, 'uint32', 0, 2);
} catch {}
try {
commandEncoder107.insertDebugMarker('\u0b9b');
} catch {}
let pipeline25 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
let texture149 = device0.createTexture({size: {width: 90}, dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder25.end();
} catch {}
try {
renderPassEncoder19.draw(0, 17, 0, 55_648_122);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer87, 4);
} catch {}
try {
renderBundleEncoder18.drawIndexed(2, 397, 0, 106_097_354, 231_874_082);
} catch {}
try {
commandEncoder129.pushDebugGroup('\u516d');
} catch {}
document.body.prepend(img1);
let buffer107 = device0.createBuffer({size: 656, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let renderBundle9 = renderBundleEncoder18.finish({});
let sampler24 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 92.86});
try {
renderPassEncoder26.draw(225, 171, 27, 78_983_935);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer18, 20);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(0, buffer74);
} catch {}
let textureView138 = texture124.createView({aspect: 'all', arrayLayerCount: 1});
try {
renderPassEncoder12.setBindGroup(1, bindGroup38, new Uint32Array(974), 472, 0);
} catch {}
try {
renderPassEncoder3.drawIndexed(3, 0, 0, 160_871_958);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer72, 'uint32', 564, 76);
} catch {}
await gc();
let textureView139 = texture59.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
computePassEncoder33.end();
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup76, new Uint32Array(1116), 47, 0);
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 120, 0, 66_451_082, 1_227_054_123);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer102, 4);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'bt709'} });
let commandEncoder136 = device0.createCommandEncoder({});
let textureView140 = texture13.createView({dimension: '2d-array'});
try {
renderPassEncoder23.beginOcclusionQuery(768);
} catch {}
try {
renderPassEncoder17.draw(1, 71, 0, 826_961_394);
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 107, 0, 946_562_721, 224_297_577);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer101, 28);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer84, 'uint16', 210, 4);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(0, buffer30, 0, 10);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup27);
} catch {}
try {
commandEncoder129.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer58, 64, new DataView(new Uint8Array(4893).map((_, i) => i).buffer), 136, 152);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 8, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(215).fill(195), /* required buffer size: 215 */
{offset: 215, bytesPerRow: 359}, {width: 43, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder137 = device0.createCommandEncoder();
let texture150 = device0.createTexture({
  size: [2976, 12, 1],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView141 = texture74.createView({baseArrayLayer: 0});
try {
computePassEncoder8.setBindGroup(2, bindGroup13);
} catch {}
try {
renderPassEncoder17.drawIndexed(0, 55, 0, -2_126_267_626, 673_121_304);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(3, buffer0, 0);
} catch {}
let pipeline26 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  multisample: {count: 1, mask: 0x1377176d},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment2',
  constants: {59_276: 1},
  targets: [{
  format: 'r16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 0, shaderLocation: 10},
          {format: 'uint32x4', offset: 0, shaderLocation: 4},
          {format: 'uint8x4', offset: 4, shaderLocation: 14},
          {format: 'unorm16x2', offset: 16, shaderLocation: 12},
          {format: 'unorm16x2', offset: 4, shaderLocation: 8},
          {format: 'uint32x3', offset: 0, shaderLocation: 15},
          {format: 'uint32x4', offset: 4, shaderLocation: 7},
          {format: 'sint32x3', offset: 4, shaderLocation: 1},
          {format: 'unorm8x2', offset: 6, shaderLocation: 3},
          {format: 'uint32x4', offset: 16, shaderLocation: 11},
          {format: 'unorm16x4', offset: 8, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 20,
        stepMode: 'vertex',
        attributes: [
          {format: 'float16x4', offset: 0, shaderLocation: 2},
          {format: 'uint16x4', offset: 0, shaderLocation: 0},
          {format: 'snorm16x4', offset: 0, shaderLocation: 5},
          {format: 'sint8x4', offset: 4, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 4, shaderLocation: 13}],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
let bindGroup89 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 3, resource: {buffer: buffer11, size: 3272}},
    {binding: 153, resource: sampler20},
    {binding: 43, resource: sampler22},
    {binding: 2, resource: externalTexture17},
    {binding: 0, resource: textureView105},
    {binding: 252, resource: textureView55},
    {binding: 571, resource: textureView119},
    {binding: 11, resource: sampler22},
    {binding: 15, resource: externalTexture19},
    {binding: 239, resource: textureView97},
    {binding: 238, resource: {buffer: buffer101}},
    {binding: 139, resource: textureView63},
    {binding: 44, resource: {buffer: buffer38}},
    {binding: 29, resource: {buffer: buffer11}},
    {binding: 1, resource: {buffer: buffer11, offset: 768}},
    {binding: 146, resource: textureView129},
    {binding: 52, resource: textureView61},
    {binding: 337, resource: {buffer: buffer11, offset: 256}},
    {binding: 303, resource: {buffer: buffer11}},
    {binding: 8, resource: {buffer: buffer62, size: 64}},
  ],
});
let commandBuffer23 = commandEncoder28.finish({});
let texture151 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 6},
  dimension: '2d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder25.setBindGroup(2, bindGroup65);
} catch {}
try {
renderPassEncoder31.beginOcclusionQuery(1355);
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder3.drawIndexed(3, 0, 0, 32_917_501);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup79, new Uint32Array(1674), 102, 0);
} catch {}
let commandEncoder138 = device0.createCommandEncoder({});
let commandBuffer24 = commandEncoder100.finish();
let texture152 = device0.createTexture({
  size: {width: 816, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture153 = device0.createTexture({
  size: [1172, 24, 1],
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder3.setBindGroup(0, bindGroup15, new Uint32Array(3820), 619, 0);
} catch {}
try {
renderPassEncoder17.end();
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 402, 0, 361_745_868, 467_488_154);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer105, 0);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer17, 'uint16', 12, 4);
} catch {}
try {
buffer45.unmap();
} catch {}
let imageData16 = new ImageData(44, 92);
let texture154 = device0.createTexture({
  size: {width: 2345, height: 48, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture155 = device0.createTexture({
  size: {width: 816, height: 1, depthOrArrayLayers: 73},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder26.drawIndexedIndirect(buffer39, 120);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer29, 128);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup42, new Uint32Array(668), 190, 1);
} catch {}
try {
buffer52.unmap();
} catch {}
try {
commandEncoder77.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 370 */
  offset: 370,
  rowsPerImage: 143,
  buffer: buffer39,
}, {
  texture: texture51,
  mipLevel: 0,
  origin: {x: 52, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img1);
let bindGroup90 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 1, resource: externalTexture8},
    {binding: 90, resource: textureView57},
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer22}},
    {binding: 3, resource: {buffer: buffer22}},
  ],
});
let texture156 = device0.createTexture({
  size: {width: 293, height: 6, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture157 = device0.createTexture({
  size: {width: 1488},
  sampleCount: 1,
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView142 = texture135.createView({mipLevelCount: 1});
try {
computePassEncoder17.setBindGroup(0, bindGroup25);
} catch {}
try {
renderPassEncoder26.setBindGroup(3, bindGroup80, new Uint32Array(508), 97, 1);
} catch {}
try {
renderPassEncoder3.draw(585, 0, 303_926_546);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer78, 12);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup66, [0]);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer18, 'uint32', 72, 2);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(1, buffer95, 0);
} catch {}
try {
commandEncoder103.copyTextureToTexture({
  texture: texture157,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture142,
  mipLevel: 0,
  origin: {x: 55, y: 0, z: 185},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder63.resolveQuerySet(querySet0, 906, 8, buffer83, 0);
} catch {}
try {
renderBundleEncoder23.insertDebugMarker('\u05c0');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 242, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(324).fill(180), /* required buffer size: 324 */
{offset: 324, bytesPerRow: 235, rowsPerImage: 33}, {width: 103, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder139 = device0.createCommandEncoder({});
let texture158 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder13.setBindGroup(2, bindGroup50);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer21, 8);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer61, 36);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(7, buffer51, 0);
} catch {}
try {
renderBundleEncoder23.setBindGroup(1, bindGroup23);
} catch {}
try {
commandEncoder80.copyBufferToTexture({
  /* bytesInLastRow: 176 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2752 */
  offset: 2752,
  buffer: buffer2,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 61, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture159 = device0.createTexture({
  size: {width: 372, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture160 = device0.createTexture({
  size: {width: 1172, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder21.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder3.draw(159, 0, 411_762_824);
} catch {}
try {
renderPassEncoder16.drawIndexed(4, 0, 0, 334_271_973);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer106, 4);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer17, 'uint32', 16, 2);
} catch {}
try {
renderBundleEncoder23.draw(159, 1, 428_089_117);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(5, buffer107, 656, 0);
} catch {}
try {
commandEncoder38.pushDebugGroup('\u193b');
} catch {}
let imageData17 = new ImageData(24, 28);
let textureView143 = texture152.createView({});
let renderPassEncoder32 = commandEncoder117.beginRenderPass({
  colorAttachments: [{
  view: textureView113,
  depthSlice: 38,
  clearValue: { r: -789.2, g: 855.4, b: -594.7, a: -700.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder6.setBindGroup(1, bindGroup77);
} catch {}
try {
renderPassEncoder3.drawIndexed(3, 0, 0, 373_968_107, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer29, 44);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer71, 'uint32', 16, 8);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline21);
} catch {}
try {
commandEncoder137.copyTextureToBuffer({
  texture: texture61,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 332 widthInBlocks: 166 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1316 */
  offset: 1316,
  rowsPerImage: 231,
  buffer: buffer11,
}, {width: 166, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let textureView144 = texture124.createView({});
let textureView145 = texture53.createView({dimension: '2d-array', format: 'r32float'});
try {
renderPassEncoder23.endOcclusionQuery();
} catch {}
try {
renderPassEncoder28.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer62, 32);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(2, buffer1, 0, 20);
} catch {}
try {
renderBundleEncoder23.drawIndexedIndirect(buffer10, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer93, 'uint16', 40, 14);
} catch {}
try {
commandEncoder114.copyTextureToTexture({
  texture: texture92,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture70,
  mipLevel: 0,
  origin: {x: 108, y: 0, z: 14},
  aspect: 'all',
},
{width: 127, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 108, y: 4 },
  flipY: false,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 3, depthOrArrayLayers: 0});
} catch {}
let pipeline27 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule6, constants: {}}});
try {
computePassEncoder16.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder3.draw(294, 0, 485_076_754);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(5, buffer51, 0, 29);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 360, height: 210, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 2, y: 0 },
  flipY: true,
}, {
  texture: texture88,
  mipLevel: 0,
  origin: {x: 191, y: 10, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let buffer108 = device0.createBuffer({size: 256, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let commandEncoder140 = device0.createCommandEncoder({});
let textureView146 = texture106.createView({format: 'r32sint'});
let renderBundle10 = renderBundleEncoder23.finish({label: '\u0ecb\u23dc\u5b0b\u0e99\ucfdb\u0c95\u55af\u{1f73f}'});
try {
renderPassEncoder24.executeBundles([renderBundle4, renderBundle4]);
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 366, 0, 10_425_524, 1_903_146_131);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(0, buffer74, 0);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline9);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  toneMapping: {mode: 'extended'},
});
} catch {}
await gc();
let bindGroup91 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 2, resource: {buffer: buffer64}}]});
let textureView147 = texture15.createView({format: 'r16uint', baseMipLevel: 0});
try {
renderPassEncoder6.setBindGroup(0, bindGroup74, new Uint32Array(357), 191, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer34, 44);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 328, new Float32Array(14757).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.678)), 543, 4);
} catch {}
let textureView148 = texture156.createView({aspect: 'all'});
let textureView149 = texture14.createView({dimension: '2d-array'});
try {
computePassEncoder10.setBindGroup(2, bindGroup52);
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup1, new Uint32Array(5381), 910, 0);
} catch {}
try {
renderPassEncoder22.draw(141, 1, 1_218_549_081);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer29, 144);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer18, 'uint32', 32, 2);
} catch {}
try {
buffer46.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer23, commandBuffer24]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData14,
  origin: { x: 1, y: 50 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 51, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {binding: 10, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 230,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let autogeneratedBindGroupLayout9 = pipeline25.getBindGroupLayout(1);
let sampler25 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 87.07,
  lodMaxClamp: 98.66,
});
try {
computePassEncoder23.setBindGroup(0, bindGroup62, new Uint32Array(281), 0, 1);
} catch {}
try {
renderPassEncoder31.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer101, 60);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer32, 'uint32', 4, 66);
} catch {}
try {
renderBundleEncoder24.insertDebugMarker('\ub77e');
} catch {}
try {
device0.queue.writeBuffer(buffer39, 52, new DataView(new ArrayBuffer(28424)), 82, 20);
} catch {}
let texture161 = device0.createTexture({size: [1172], dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView150 = texture152.createView({dimension: '2d-array', format: 'rgba8unorm'});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder27.setBindGroup(1, bindGroup11, new Uint32Array(2676), 1_064, 0);
} catch {}
try {
renderPassEncoder18.setBindGroup(2, bindGroup38, new Uint32Array(51), 2, 0);
} catch {}
try {
renderPassEncoder22.draw(117, 1, 419_039_432, 3);
} catch {}
try {
renderPassEncoder22.drawIndexed(12, 1, 2, 1_202_751_844);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer87, 4);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(1, buffer106, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup66, [0]);
} catch {}
try {
commandEncoder89.resolveQuerySet(querySet2, 3, 1, buffer11, 0);
} catch {}
let texture162 = device0.createTexture({
  size: [1488, 6, 1],
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16uint'],
});
let sampler26 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.92,
  maxAnisotropy: 2,
});
try {
computePassEncoder35.setBindGroup(1, bindGroup63, new Uint32Array(398), 43, 0);
} catch {}
try {
renderPassEncoder6.drawIndexed(1, 203, 0, 809_712_913, 31_365_097);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer103, 'uint16', 8, 2);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup27);
} catch {}
let textureView151 = texture43.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder31.beginOcclusionQuery(818);
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 6, 0, 56_129_542);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer38, 4);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup60, new Uint32Array(971), 38, 0);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer108, 'uint32', 24, 83);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer97, 312, 35);
} catch {}
try {
  await buffer96.mapAsync(GPUMapMode.READ, 32, 48);
} catch {}
await gc();
let bindGroup92 = device0.createBindGroup({
  label: '\u95dc\u021d',
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 2, resource: {buffer: buffer62, size: 12}}],
});
let buffer109 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer71, 4); };
} catch {}
try {
renderPassEncoder25.setBindGroup(3, bindGroup15);
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 3, 2, 24_533_978, 11);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline14);
} catch {}
let bindGroup93 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 2, resource: {buffer: buffer64}},
    {binding: 0, resource: textureView1},
    {binding: 90, resource: textureView43},
    {binding: 3, resource: {buffer: buffer61, offset: 0}},
    {binding: 1, resource: externalTexture13},
  ],
});
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder3.drawIndexed(3, 0, 0, -2_132_595_555);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline6);
} catch {}
let bindGroup94 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 52, resource: textureView77},
    {binding: 252, resource: textureView70},
    {binding: 239, resource: textureView97},
    {binding: 2, resource: externalTexture0},
    {binding: 0, resource: textureView60},
    {binding: 303, resource: {buffer: buffer97, size: 1000}},
    {binding: 571, resource: textureView119},
    {binding: 43, resource: sampler25},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 139, resource: textureView74},
    {binding: 44, resource: {buffer: buffer101}},
    {binding: 11, resource: sampler6},
    {binding: 153, resource: sampler23},
    {binding: 1, resource: {buffer: buffer11}},
    {binding: 8, resource: {buffer: buffer101}},
    {binding: 238, resource: {buffer: buffer54}},
    {binding: 15, resource: externalTexture14},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 146, resource: textureView98},
    {binding: 29, resource: {buffer: buffer97, size: 1112}},
  ],
});
let commandEncoder141 = device0.createCommandEncoder();
let commandBuffer25 = commandEncoder57.finish();
try {
renderPassEncoder12.drawIndexed(3, 2, 2, -1_724_792_257, 1);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer71, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(6, buffer106, 0, 40);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer13, 0, 1);
} catch {}
let commandEncoder142 = device0.createCommandEncoder({});
let textureView152 = texture105.createView({format: 'rg16sint'});
try {
computePassEncoder17.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder31.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder16.drawIndexed(5, 0, 0, 294_515_404);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup69, new Uint32Array(1836), 329, 1);
} catch {}
try {
renderBundleEncoder4.draw(0, 98, 0, 1_156_192_152);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 11}
*/
{
  source: videoFrame11,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture163 = device0.createTexture({
  size: {width: 45, height: 26, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView153 = texture64.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder19.drawIndexed(2, 522, 0, 278_672_748, 24_826_486);
} catch {}
try {
renderBundleEncoder19.drawIndirect(buffer78, 8);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer93, 'uint16', 8, 3);
} catch {}
let buffer110 = device0.createBuffer({
  size: 75,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder36 = commandEncoder92.beginComputePass();
let externalTexture21 = device0.importExternalTexture({source: videoFrame7});
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1, 2); };
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer72, 28);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer34, 84);
} catch {}
try {
computePassEncoder16.setBindGroup(0, bindGroup42, [0]);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.drawIndexed(1, 39, 0, 65_010_014, 1_106_592_292);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer18, 4);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer87, 4);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup28, new Uint32Array(179), 14, 1);
} catch {}
try {
commandEncoder68.clearBuffer(buffer94, 16);
} catch {}
try {
commandEncoder38.popDebugGroup();
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'film', transfer: 'hlg'} });
try {
externalTexture18.label = '\u480b\u{1f7fe}\u0134\u0f8c\uee63\u4557';
} catch {}
let texture164 = device0.createTexture({
  size: {width: 1172, height: 24, depthOrArrayLayers: 22},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder23.setBindGroup(0, bindGroup34, new Uint32Array(2550), 133, 0);
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 4, 0, 156_722_561, 51_075_054);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer40, 36);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder4.drawIndexedIndirect(buffer77, 48);
} catch {}
try {
device0.queue.submit([commandBuffer25]);
} catch {}
let bindGroup95 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 43, resource: sampler5},
    {binding: 239, resource: textureView62},
    {binding: 146, resource: textureView60},
    {binding: 15, resource: externalTexture20},
    {binding: 252, resource: textureView70},
    {binding: 238, resource: {buffer: buffer38}},
    {binding: 153, resource: sampler23},
    {binding: 52, resource: textureView61},
    {binding: 0, resource: textureView60},
    {binding: 303, resource: {buffer: buffer11}},
    {binding: 11, resource: sampler13},
    {binding: 44, resource: {buffer: buffer98}},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 2, resource: externalTexture16},
    {binding: 571, resource: textureView119},
    {binding: 139, resource: textureView63},
    {binding: 29, resource: {buffer: buffer11}},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 8, resource: {buffer: buffer38}},
    {binding: 1, resource: {buffer: buffer11, offset: 256}},
  ],
});
let commandEncoder143 = device0.createCommandEncoder({});
let texture165 = device0.createTexture({
  size: [2345, 48, 1],
  dimension: '2d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView154 = texture76.createView({label: '\u62e9\ub3f0\u0afe\u7990\u00b7\u02e9\u09ab\u746d\u{1fa1f}', baseMipLevel: 0, mipLevelCount: 1});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle11 = renderBundleEncoder4.finish({});
try {
computePassEncoder19.setBindGroup(0, bindGroup55, new Uint32Array(395), 15, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer67, 8); };
} catch {}
try {
renderPassEncoder19.draw(0, 35, 0, 1_851_563_317);
} catch {}
try {
renderBundleEncoder19.drawIndexed(3, 519, 1, 1_063_200_743, 341_019_520);
} catch {}
try {
renderBundleEncoder19.drawIndexedIndirect(buffer62, 16);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline23);
} catch {}
let arrayBuffer6 = buffer96.getMappedRange(32, 28);
let commandEncoder144 = device0.createCommandEncoder({});
try {
renderPassEncoder9.setBindGroup(3, bindGroup59);
} catch {}
try {
renderPassEncoder6.draw(0, 161, 0, 966_085_463);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer93, 'uint16', 0, 51);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(1, buffer11, 92, 160);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(5); };
} catch {}
try {
externalTexture4.label = '\u67fe\uecb7\u8309\u{1fd10}\u69d8\u02b4';
} catch {}
let buffer111 = device0.createBuffer({size: 416, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder16.drawIndexed(4, 0, 1, 1_409_595_650);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer105, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(3, buffer13);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup93);
} catch {}
let arrayBuffer7 = buffer96.getMappedRange(64, 4);
let recycledExplicitBindGroupLayout7 = pipeline10.getBindGroupLayout(0);
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder19.draw(0, 57, 0, 588_134_802);
} catch {}
try {
renderBundleEncoder19.drawIndirect(buffer62, 68);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer108, 'uint32', 44, 23);
} catch {}
try {
device0.queue.writeBuffer(buffer53, 68, new Uint32Array(13257).map((_, i) => i * 2), 18, 12);
} catch {}
let bindGroup96 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 90, resource: textureView57},
    {binding: 1, resource: externalTexture5},
    {binding: 2, resource: {buffer: buffer92}},
    {binding: 0, resource: textureView51},
    {binding: 3, resource: {buffer: buffer61}},
  ],
});
try {
renderPassEncoder19.setBindGroup(0, bindGroup60, new Uint32Array(3329), 548, 0);
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer71, 20);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer102, 12);
} catch {}
let commandEncoder145 = device0.createCommandEncoder({});
let texture166 = device0.createTexture({
  size: {width: 586, height: 12, depthOrArrayLayers: 61},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer102, 4); };
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup93, new Uint32Array(1564), 263, 0);
} catch {}
try {
renderPassEncoder12.draw(139, 0, 609_943_634, 1);
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 94, 0, 401_071_237, 628_056_148);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer102, 12);
} catch {}
try {
renderBundleEncoder19.drawIndexed(2, 250, 0, 29_199_952, 785_956_720);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer92, 'uint32', 44, 31);
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(55); };
} catch {}
let commandEncoder146 = device0.createCommandEncoder({});
let externalTexture22 = device0.importExternalTexture({source: videoFrame14, colorSpace: 'srgb'});
try {
renderPassEncoder30.setBindGroup(3, bindGroup17, [256]);
} catch {}
try {
renderPassEncoder12.drawIndexed(3, 6, 1, 82_536_382);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer110, 0);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer102, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer32, 'uint32', 28, 6);
} catch {}
try {
renderBundleEncoder19.drawIndexedIndirect(buffer110, 12);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer93, 'uint32', 20, 162);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  alphaMode: 'premultiplied',
});
} catch {}
let texture167 = device0.createTexture({
  size: [360, 210, 1],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView155 = texture56.createView({});
try {
renderPassEncoder19.draw(0, 210, 0, 2_145_890_563);
} catch {}
try {
renderPassEncoder6.drawIndexed(1, 860, 0, 943_001_493, 814_511_032);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer77, 0);
} catch {}
try {
renderBundleEncoder19.drawIndirect(buffer39, 240);
} catch {}
try {
commandEncoder131.copyTextureToTexture({
  texture: texture19,
  mipLevel: 1,
  origin: {x: 411, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture116,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer112 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture168 = device0.createTexture({
  size: [2976, 12, 1],
  sampleCount: 4,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundle12 = renderBundleEncoder19.finish();
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup79, new Uint32Array(707), 216, 0);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer101, 4);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline9);
} catch {}
try {
commandEncoder139.copyBufferToTexture({
  /* bytesInLastRow: 472 widthInBlocks: 59 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 224 */
  offset: 224,
  bytesPerRow: 5120,
  rowsPerImage: 411,
  buffer: buffer107,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 70, y: 3, z: 0},
  aspect: 'all',
}, {width: 59, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer54, 12, new Uint32Array(1365).map((_, i) => i * 7), 73, 8);
} catch {}
let promise15 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4}});
let buffer113 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder147 = device0.createCommandEncoder({});
try {
renderPassEncoder26.setBindGroup(1, bindGroup36);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup61, new Uint32Array(1612), 101, 0);
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder26.drawIndexed(9, 63, 7, 871_787_074, 742_755_732);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer106, 8);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer103, 'uint32', 4, 4);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup71);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(4, buffer22, 40, 14);
} catch {}
let commandEncoder148 = device0.createCommandEncoder({});
let textureView156 = texture114.createView({});
let computePassEncoder37 = commandEncoder123.beginComputePass();
let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
computePassEncoder37.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer93, 'uint16', 180, 2);
} catch {}
try {
globalThis.someLabel = externalTexture0.label;
} catch {}
let bindGroup97 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 29, resource: {buffer: buffer97, size: 1092}},
    {binding: 52, resource: textureView61},
    {binding: 43, resource: sampler24},
    {binding: 15, resource: externalTexture2},
    {binding: 153, resource: sampler16},
    {binding: 571, resource: textureView119},
    {binding: 8, resource: {buffer: buffer34}},
    {binding: 1, resource: {buffer: buffer11}},
    {binding: 0, resource: textureView129},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 44, resource: {buffer: buffer101}},
    {binding: 146, resource: textureView129},
    {binding: 239, resource: textureView62},
    {binding: 11, resource: sampler24},
    {binding: 252, resource: textureView86},
    {binding: 139, resource: textureView63},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 2, resource: externalTexture2},
    {binding: 303, resource: {buffer: buffer97, size: 964}},
    {binding: 238, resource: {buffer: buffer64}},
  ],
});
let commandEncoder149 = device0.createCommandEncoder({});
let textureView157 = texture85.createView({mipLevelCount: 1});
let texture169 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
try {
computePassEncoder35.end();
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 1, 1, -1_641_076_843, 5);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer75, 'uint32', 12, 11);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer13, 0);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline18);
} catch {}
document.body.append(canvas0);
let buffer114 = device0.createBuffer({size: 64, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let commandEncoder150 = device0.createCommandEncoder({});
let texture170 = device0.createTexture({
  size: {width: 1488, height: 6, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture171 = device0.createTexture({size: [1488, 6, 1], format: 'r16uint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let textureView158 = texture143.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder38 = commandEncoder105.beginComputePass();
try {
computePassEncoder38.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder26.draw(1, 120, 0, 2_440_622_958);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer40, 60);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup66, new Uint32Array(221), 9, 1);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(0, buffer22, 0, 2);
} catch {}
let pipeline28 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {}}});
let imageData18 = new ImageData(12, 48);
let bindGroup98 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 8, resource: {buffer: buffer22}},
    {binding: 0, resource: textureView129},
    {binding: 303, resource: {buffer: buffer97, offset: 0, size: 972}},
    {binding: 146, resource: textureView60},
    {binding: 15, resource: externalTexture12},
    {binding: 153, resource: sampler24},
    {binding: 29, resource: {buffer: buffer97, size: 1108}},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 139, resource: textureView74},
    {binding: 238, resource: {buffer: buffer64}},
    {binding: 239, resource: textureView62},
    {binding: 2, resource: externalTexture15},
    {binding: 571, resource: textureView65},
    {binding: 52, resource: textureView61},
    {binding: 1, resource: {buffer: buffer11}},
    {binding: 44, resource: {buffer: buffer74, size: 12}},
    {binding: 43, resource: sampler5},
    {binding: 252, resource: textureView86},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 11, resource: sampler6},
  ],
});
let buffer115 = device0.createBuffer({size: 16, usage: GPUBufferUsage.VERTEX});
let textureView159 = texture152.createView({dimension: '2d-array', arrayLayerCount: 1});
let externalTexture23 = device0.importExternalTexture({source: videoFrame11});
try {
computePassEncoder23.setBindGroup(1, bindGroup58, new Uint32Array(1242), 62, 0);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer106, 24);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer82, 'uint32', 8, 19);
} catch {}
try {
buffer109.unmap();
} catch {}
try {
commandEncoder141.insertDebugMarker('\u210f');
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 105, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas4,
  origin: { x: 4, y: 0 },
  flipY: false,
}, {
  texture: texture56,
  mipLevel: 0,
  origin: {x: 34, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 4, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(26); };
} catch {}
let bindGroup99 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 70, resource: textureView77},
    {binding: 24, resource: textureView130},
    {binding: 2, resource: textureView60},
    {binding: 3, resource: textureView70},
  ],
});
let externalTexture24 = device0.importExternalTexture({source: videoFrame12, colorSpace: 'srgb'});
try {
renderPassEncoder16.drawIndexedIndirect(buffer77, 16);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer109, 'uint32', 68, 17);
} catch {}
try {
renderBundleEncoder3.draw(0, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let buffer116 = device0.createBuffer({size: 32, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder26.draw(1, 14, 0, 205_207_486);
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 2, 0, 210_240_571, 749_894_064);
} catch {}
try {
commandEncoder119.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 968 */
  offset: 968,
  bytesPerRow: 16128,
  buffer: buffer72,
}, {
  texture: texture48,
  mipLevel: 2,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder145.copyTextureToBuffer({
  texture: texture148,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 132 widthInBlocks: 66 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 652 */
  offset: 652,
  buffer: buffer97,
}, {width: 66, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder151 = device0.createCommandEncoder({});
let texture172 = device0.createTexture({size: [360], dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder17.setBindGroup(3, bindGroup94, [0, 0]);
} catch {}
try {
computePassEncoder23.setBindGroup(3, bindGroup29, new Uint32Array(2), 0, 0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer18, 0);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(0, buffer30, 0, 41);
} catch {}
try {
renderBundleEncoder31.setBindGroup(2, bindGroup77);
} catch {}
try {
renderBundleEncoder3.drawIndexedIndirect(buffer106, 4);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(6, buffer9, 60);
} catch {}
let commandEncoder152 = device0.createCommandEncoder({});
let texture173 = device0.createTexture({
  size: [45],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup87, new Uint32Array(8638), 892, 0);
} catch {}
try {
renderPassEncoder19.drawIndexed(2, 90, 0, 519_506_786, 661_869_223);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer105, 0);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer78, 4);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline26);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(2, buffer51);
} catch {}
try {
commandEncoder81.resolveQuerySet(querySet1, 11, 6, buffer109, 0);
} catch {}
let texture174 = device0.createTexture({
  size: {width: 204, height: 1, depthOrArrayLayers: 90},
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder26.setBindGroup(0, bindGroup64, new Uint32Array(2143), 606, 0);
} catch {}
try {
renderPassEncoder26.draw(1, 115, 0, 107_789_189);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer77, 'uint16', 34, 108);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup88, new Uint32Array(1899), 23, 1);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer72, 'uint16', 158, 72);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline7);
} catch {}
let commandEncoder153 = device0.createCommandEncoder({});
let textureView160 = texture92.createView({label: '\u10eb\u0647\ua332\u0aa2\u683e\ud5b4\u{1fcd0}\u3d2a', dimension: '2d-array'});
let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], stencilReadOnly: true});
try {
computePassEncoder22.setBindGroup(3, bindGroup6, new Uint32Array(2274), 728, 0);
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 9, 0, 247_771_258, 2);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer77, 12);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline10);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder126.copyBufferToBuffer(buffer55, 4, buffer99, 4, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer34, 204, new DataView(new ArrayBuffer(6279)), 646, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 372, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 122, y: 19 },
  flipY: true,
}, {
  texture: texture159,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder32.setBindGroup(0, bindGroup80, new Uint32Array(1166), 402, 1);
} catch {}
try {
renderPassEncoder32.setBindGroup(3, bindGroup22);
} catch {}
try {
renderPassEncoder19.draw(0, 228, 0, 251_416_979);
} catch {}
try {
renderPassEncoder16.drawIndexed(1, 0, 0, 1_367_378_990);
} catch {}
try {
renderPassEncoder19.drawIndexedIndirect(buffer10, 4);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer61, 60);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(6, buffer107, 48, 46);
} catch {}
try {
renderBundleEncoder3.drawIndexedIndirect(buffer40, 16);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer108, 'uint16', 2, 205);
} catch {}
try {
renderBundleEncoder31.setPipeline(pipeline18);
} catch {}
try {
commandEncoder63.copyTextureToTexture({
  texture: texture94,
  mipLevel: 2,
  origin: {x: 1, y: 1, z: 2},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder25.insertDebugMarker('\u{1f713}');
} catch {}
let bindGroup100 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: externalTexture3},
    {binding: 3, resource: {buffer: buffer76}},
    {binding: 2, resource: {buffer: buffer112}},
    {binding: 90, resource: textureView8},
    {binding: 0, resource: textureView51},
  ],
});
let commandEncoder154 = device0.createCommandEncoder();
let renderBundle13 = renderBundleEncoder3.finish();
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder12.drawIndexed(2, 7, 0, 1_855_028_065, 1);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer38, 4);
} catch {}
try {
renderBundleEncoder22.setBindGroup(1, bindGroup88, new Uint32Array(2795), 201, 1);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline14);
} catch {}
try {
buffer40.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer45, 28, new Uint32Array(20599).map((_, i) => i * 1), 1127, 12);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer102, 0);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer62, 56);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(1, buffer56, 0, 22);
} catch {}
let bindGroup101 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 11, resource: sampler24},
    {binding: 29, resource: {buffer: buffer11}},
    {binding: 252, resource: textureView84},
    {binding: 15, resource: externalTexture10},
    {binding: 3, resource: {buffer: buffer11, offset: 0, size: 3140}},
    {binding: 43, resource: sampler5},
    {binding: 303, resource: {buffer: buffer11, size: 1040}},
    {binding: 239, resource: textureView62},
    {binding: 146, resource: textureView157},
    {binding: 0, resource: textureView105},
    {binding: 337, resource: {buffer: buffer11}},
    {binding: 571, resource: textureView65},
    {binding: 153, resource: sampler18},
    {binding: 44, resource: {buffer: buffer11}},
    {binding: 1, resource: {buffer: buffer11}},
    {binding: 2, resource: externalTexture22},
    {binding: 238, resource: {buffer: buffer22}},
    {binding: 139, resource: textureView63},
    {binding: 52, resource: textureView61},
    {binding: 8, resource: {buffer: buffer40}},
  ],
});
let buffer117 = device0.createBuffer({size: 340, usage: GPUBufferUsage.STORAGE});
let textureView161 = texture24.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 29});
try {
computePassEncoder23.setBindGroup(3, bindGroup38);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(3, buffer51, 40, 0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(0, buffer74, 4, 46);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer53, 144, new Float32Array(8177).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.886)), 1086, 4);
} catch {}
let bindGroup102 = device0.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 2, resource: {buffer: buffer76}}]});
let commandEncoder155 = device0.createCommandEncoder({});
let texture175 = device0.createTexture({
  size: {width: 744},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let texture176 = gpuCanvasContext2.getCurrentTexture();
let textureView162 = texture85.createView({});
try {
computePassEncoder17.setBindGroup(1, bindGroup63, new Uint32Array(535), 0, 0);
} catch {}
try {
renderPassEncoder19.end();
} catch {}
try {
renderPassEncoder12.draw(245, 2, 437_950_148, 3);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer62, 0);
} catch {}
let buffer118 = device0.createBuffer({size: 264, usage: GPUBufferUsage.VERTEX});
let sampler27 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'never',
  maxAnisotropy: 7,
});
try {
renderPassEncoder4.setBindGroup(1, bindGroup60);
} catch {}
try {
renderBundleEncoder22.draw(0, 10, 0, 1_120_737_898);
} catch {}
try {
renderBundleEncoder31.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder28.setBindGroup(3, bindGroup59);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer18, 16);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer72);
} catch {}
try {
renderBundleEncoder31.draw(0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer28, 104, new Uint32Array(6686).map((_, i) => i * 9), 76, 4);
} catch {}
let texture177 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 17},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView163 = texture125.createView({aspect: 'all'});
try {
renderPassEncoder26.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder26.draw(1, 173, 0, 625_045_006);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer12, 0, 2);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer102, 4);
} catch {}
let arrayBuffer8 = buffer96.getMappedRange(72, 0);
let pipeline29 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 48,
        attributes: [
          {format: 'uint32x2', offset: 0, shaderLocation: 4},
          {format: 'unorm16x2', offset: 0, shaderLocation: 6},
          {format: 'snorm16x4', offset: 0, shaderLocation: 15},
          {format: 'snorm8x4', offset: 0, shaderLocation: 0},
          {format: 'float32', offset: 4, shaderLocation: 9},
          {format: 'unorm8x4', offset: 0, shaderLocation: 11},
          {format: 'float16x2', offset: 4, shaderLocation: 2},
          {format: 'sint32x2', offset: 4, shaderLocation: 1},
          {format: 'uint32', offset: 8, shaderLocation: 12},
          {format: 'uint8x4', offset: 4, shaderLocation: 14},
          {format: 'sint8x4', offset: 12, shaderLocation: 13},
          {format: 'float32', offset: 20, shaderLocation: 5},
          {format: 'sint32', offset: 8, shaderLocation: 3},
          {format: 'uint16x2', offset: 16, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 116,
        attributes: [
          {format: 'snorm16x4', offset: 12, shaderLocation: 7},
          {format: 'unorm8x4', offset: 48, shaderLocation: 8},
        ],
      },
    ],
  },
});
let videoFrame21 = new VideoFrame(videoFrame5, {timestamp: 0});
let texture178 = device0.createTexture({
  size: {width: 102},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder32.setBindGroup(2, bindGroup41);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(1384);
} catch {}
try {
renderPassEncoder26.drawIndexed(10, 267, 0, -2_138_598_734, 763_777_814);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer39, 80);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer2, 3_304, 579);
} catch {}
let pipeline30 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
let imageData19 = new ImageData(148, 28);
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let texture179 = device0.createTexture({size: [180, 105, 1], format: 'r16uint', usage: GPUTextureUsage.COPY_DST});
let renderBundle14 = renderBundleEncoder22.finish();
try {
computePassEncoder19.setBindGroup(3, bindGroup86);
} catch {}
try {
computePassEncoder32.setBindGroup(2, bindGroup101, new Uint32Array(296), 7, 2);
} catch {}
try {
renderPassEncoder4.draw(189, 0, 173_536_494);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer34, 48);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer84, 'uint16', 12, 57);
} catch {}
try {
renderBundleEncoder31.draw(0, 0);
} catch {}
try {
renderPassEncoder13.insertDebugMarker('\uf25f');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 26, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let adapter1 = await navigator.gpu.requestAdapter({});
let buffer119 = device0.createBuffer({size: 20, usage: GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder24.setBindGroup(3, bindGroup80, [0]);
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(0, buffer51);
} catch {}
try {
buffer85.unmap();
} catch {}
let imageData20 = new ImageData(12, 80);
try {
adapter1.label = '\u66f8\uaf8a';
} catch {}
let externalTexture25 = device0.importExternalTexture({source: videoFrame14});
try {
computePassEncoder29.setBindGroup(0, bindGroup64);
} catch {}
try {
renderPassEncoder26.draw(1, 404, 0, 447_448_563);
} catch {}
try {
renderPassEncoder16.drawIndexed(1, 0, 0, 397_670_261);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline7);
} catch {}
try {
commandEncoder147.clearBuffer(buffer11);
} catch {}
document.body.append(img2);
let canvas1 = document.createElement('canvas');
let commandEncoder156 = device0.createCommandEncoder();
let texture180 = device0.createTexture({
  size: {width: 45, height: 26, depthOrArrayLayers: 352},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder4.setBindGroup(1, bindGroup40);
} catch {}
try {
renderPassEncoder16.draw(0, 0);
} catch {}
try {
renderPassEncoder26.drawIndexed(2, 363, 1, 714_624_252, 1_317_415_800);
} catch {}
try {
renderBundleEncoder21.setBindGroup(1, bindGroup69, new Uint32Array(191), 3, 1);
} catch {}
try {
renderBundleEncoder31.drawIndexedIndirect(buffer105, 0);
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 53, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer120 = device0.createBuffer({
  size: 12032,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture181 = device0.createTexture({
  size: [1172, 24, 90],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup53);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer75, 'uint16', 4, 1);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(4, buffer9, 44, 57);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup22);
} catch {}
try {
renderBundleEncoder12.drawIndirect(buffer62, 4);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer99, 8, new Float32Array(1616).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.1105)), 264, 0);
} catch {}
let pipeline31 = await promise15;
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let imageData21 = new ImageData(100, 76);
let renderPassEncoder33 = commandEncoder125.beginRenderPass({colorAttachments: [{view: textureView12, loadOp: 'load', storeOp: 'store'}]});
try {
renderPassEncoder26.draw(1, 65, 0, 82_570_942);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(6, buffer2, 2_244);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let bindGroup103 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 3, resource: {buffer: buffer34}}, {binding: 2, resource: {buffer: buffer116, offset: 0}}],
});
let commandEncoder157 = device0.createCommandEncoder({});
let textureView164 = texture74.createView({format: 'r16uint'});
try {
renderPassEncoder24.setBindGroup(2, bindGroup70, new Uint32Array(1471), 446, 0);
} catch {}
try {
renderPassEncoder26.draw(1, 60, 0, 4_248_395_397);
} catch {}
try {
commandEncoder109.copyBufferToTexture({
  /* bytesInLastRow: 70 widthInBlocks: 35 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2648 */
  offset: 2648,
  buffer: buffer120,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {width: 35, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder144.copyTextureToBuffer({
  texture: texture167,
  mipLevel: 0,
  origin: {x: 59, y: 45, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 214 widthInBlocks: 107 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 676 */
  offset: 676,
  bytesPerRow: 768,
  buffer: buffer11,
}, {width: 107, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas1);
let buffer121 = device0.createBuffer({size: 144, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
let commandEncoder158 = device0.createCommandEncoder();
let commandBuffer26 = commandEncoder3.finish();
try {
renderPassEncoder26.setBindGroup(0, bindGroup32, new Uint32Array(102), 2, 0);
} catch {}
try {
renderPassEncoder4.draw(351, 0, 49_603_906);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer112, 'uint16', 2, 3);
} catch {}
try {
renderBundleEncoder31.drawIndirect(buffer78, 0);
} catch {}
try {
device0.queue.submit([commandBuffer26]);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let recycledExplicitBindGroupLayout8 = pipeline17.getBindGroupLayout(1);
let bindGroup104 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 90, resource: textureView8},
    {binding: 2, resource: {buffer: buffer28}},
    {binding: 0, resource: textureView1},
    {binding: 1, resource: externalTexture20},
    {binding: 3, resource: {buffer: buffer40, offset: 0}},
  ],
});
let buffer122 = device0.createBuffer({size: 160, usage: GPUBufferUsage.UNIFORM});
let commandEncoder159 = device0.createCommandEncoder({});
let texture182 = device0.createTexture({
  size: [372, 1, 22],
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture183 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder23.setBindGroup(1, bindGroup60);
} catch {}
try {
renderPassEncoder26.draw(1, 220, 0, 1_399_321_153);
} catch {}
try {
renderPassEncoder4.drawIndexed(1, 0, 0, 207_708_505);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer18, 4);
} catch {}
try {
renderBundleEncoder31.draw(0, 0);
} catch {}
try {
renderBundleEncoder12.drawIndexedIndirect(buffer72, 124);
} catch {}
try {
renderBundleEncoder12.drawIndirect(buffer110, 8);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline21);
} catch {}
let bindGroup105 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout7,
  entries: [
    {binding: 1, resource: externalTexture8},
    {binding: 0, resource: textureView0},
    {binding: 3, resource: {buffer: buffer34}},
    {binding: 2, resource: {buffer: buffer76}},
    {binding: 90, resource: textureView57},
  ],
});
let buffer123 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView165 = texture182.createView({});
try {
renderPassEncoder16.drawIndexedIndirect(buffer120, 476);
} catch {}
try {
renderBundleEncoder31.setBindGroup(1, bindGroup100, new Uint32Array(358), 43, 0);
} catch {}
try {
renderBundleEncoder31.drawIndirect(buffer105, 0);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(0, buffer2, 2_032);
} catch {}
try {
commandEncoder98.resolveQuerySet(querySet0, 6, 0, buffer119, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer54, 0, new Uint32Array(5079).map((_, i) => i * 7), 2327, 8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2976, height: 12, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 90, y: 2 },
  flipY: true,
}, {
  texture: texture150,
  mipLevel: 0,
  origin: {x: 155, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 47, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
  await promise16;
} catch {}
document.body.prepend(canvas0);
let recycledExplicitBindGroupLayout9 = pipeline6.getBindGroupLayout(1);
let texture184 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  sampleCount: 4,
  dimension: '2d',
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder26.draw(1, 352, 0, 93_917_930);
} catch {}
try {
renderPassEncoder26.drawIndexed(4, 176, 5, 166_486_103, 1_670_283_697);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer34, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer21, 8);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup51);
} catch {}
try {
renderBundleEncoder21.drawIndexedIndirect(buffer29, 60);
} catch {}
try {
commandEncoder119.resolveQuerySet(querySet2, 0, 0, buffer120, 768);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 360, height: 210, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 4, y: 0 },
  flipY: false,
}, {
  texture: texture88,
  mipLevel: 0,
  origin: {x: 269, y: 10, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer124 = device0.createBuffer({size: 340, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let textureView166 = texture184.createView({arrayLayerCount: 1});
let texture185 = device0.createTexture({
  size: {width: 586, height: 12, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler28 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 97.93, maxAnisotropy: 14});
try {
renderPassEncoder16.end();
} catch {}
try {
renderPassEncoder26.draw(1, 376, 0, 231_488_233);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer110, 4);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer37);
} catch {}
try {
renderBundleEncoder31.draw(0, 0);
} catch {}
try {
renderBundleEncoder31.drawIndirect(buffer40, 16);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer112, 'uint16', 0, 0);
} catch {}
try {
commandEncoder120.copyBufferToBuffer(buffer37, 12, buffer83, 16, 0);
} catch {}
try {
commandEncoder73.resolveQuerySet(querySet2, 0, 1, buffer14, 0);
} catch {}
let pipeline32 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment3',
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 1672, shaderLocation: 6},
          {format: 'sint16x4', offset: 112, shaderLocation: 1},
          {format: 'float16x2', offset: 188, shaderLocation: 7},
          {format: 'float16x4', offset: 344, shaderLocation: 2},
          {format: 'float32x2', offset: 272, shaderLocation: 0},
          {format: 'uint8x4', offset: 168, shaderLocation: 14},
          {format: 'float32x4', offset: 280, shaderLocation: 8},
          {format: 'sint16x4', offset: 264, shaderLocation: 13},
          {format: 'unorm16x2', offset: 132, shaderLocation: 9},
          {format: 'sint32x4', offset: 4, shaderLocation: 3},
          {format: 'uint16x4', offset: 1208, shaderLocation: 4},
          {format: 'uint8x4', offset: 172, shaderLocation: 12},
          {format: 'float32x4', offset: 128, shaderLocation: 5},
          {format: 'float32x4', offset: 244, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 172, shaderLocation: 15},
        ],
      },
      {arrayStride: 12, attributes: [{format: 'uint16x4', offset: 0, shaderLocation: 10}]},
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
let gpuCanvasContext7 = canvas1.getContext('webgpu');
let adapter2 = await navigator.gpu.requestAdapter({});
let device1 = await adapter1.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
    'timestamp-query',
  ],
  requiredLimits: {
    maxBindGroups: 4,
    maxVertexBufferArrayStride: 2048,
    maxUniformBufferBindingSize: 29587078,
    maxStorageBufferBindingSize: 167656092,
    maxSamplersPerShaderStage: 16,
  },
});
let commandEncoder160 = device0.createCommandEncoder({});
let texture186 = device0.createTexture({size: [2976], dimension: '1d', format: 'r16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder9.setBindGroup(3, bindGroup105);
} catch {}
try {
renderPassEncoder4.drawIndexed(1, 0, 0, 93_479_231);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer106, 24);
} catch {}
try {
renderBundleEncoder12.drawIndexedIndirect(buffer21, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer32, 0, new Float32Array(34515).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.016)), 23735, 12);
} catch {}
let buffer125 = device0.createBuffer({size: 140, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let renderBundle15 = renderBundleEncoder21.finish({});
try {
renderBundleEncoder12.drawIndexedIndirect(buffer110, 8);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 8, new DataView(new ArrayBuffer(4683)), 596, 0);
} catch {}
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470bg', transfer: 'hlg'} });
let commandEncoder161 = device0.createCommandEncoder();
let commandBuffer27 = commandEncoder39.finish();
let texture187 = device0.createTexture({
  size: {width: 744, height: 3, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder36.setBindGroup(1, bindGroup38);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder31.drawIndexedIndirect(buffer77, 16);
} catch {}
try {
renderBundleEncoder12.drawIndirect(buffer102, 0);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer71, 'uint16', 8, 3);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let commandEncoder162 = device0.createCommandEncoder({label: '\u072e\u{1ff4e}\u{1f6cd}\u5776\u3e16\u8913\u6e74\ub0f9\u0f2a\u357e'});
try {
computePassEncoder10.setPipeline(pipeline31);
} catch {}
try {
renderPassEncoder26.drawIndexed(12, 155, 3, 37_568_730, 297_275_381);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer86, 'uint16', 26, 76);
} catch {}
try {
renderBundleEncoder31.setBindGroup(1, bindGroup27);
} catch {}
let promise18 = device0.queue.onSubmittedWorkDone();
let imageData22 = new ImageData(4, 56);
let commandEncoder163 = device1.createCommandEncoder({});
let promise19 = device1.queue.onSubmittedWorkDone();
let texture188 = device1.createTexture({
  size: {width: 6, height: 60, depthOrArrayLayers: 66},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture189 = device1.createTexture({
  size: {width: 1},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(54); };
} catch {}
let buffer126 = device1.createBuffer({size: 84, usage: GPUBufferUsage.VERTEX});
let commandEncoder164 = device1.createCommandEncoder({});
let texture190 = device1.createTexture({
  size: {width: 3, height: 30, depthOrArrayLayers: 66},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
await gc();
let buffer127 = device0.createBuffer({size: 478, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let texture191 = device0.createTexture({
  size: {width: 586},
  sampleCount: 1,
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder21.beginOcclusionQuery(2311);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'bt2020_12bit'} });
try {
renderPassEncoder26.drawIndexedIndirect(buffer105, 8);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer10, 0);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline20);
} catch {}
try {
device0.queue.submit([commandBuffer27]);
} catch {}
let renderBundle16 = renderBundleEncoder12.finish({});
try {
renderPassEncoder26.draw(1, 133, 0, 372_132_824);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 67, 0, 470_145_379, 5_542_470);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer10, 4);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, buffer74, 0, 13);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup36);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer18, 'uint32', 20, 18);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(7, buffer30, 64);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 105, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 6, y: 0 },
  flipY: true,
}, {
  texture: texture56,
  mipLevel: 0,
  origin: {x: 71, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 14, height: 2, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img3);
let textureView167 = texture188.createView({dimension: '2d', baseArrayLayer: 26});
let computePassEncoder39 = commandEncoder164.beginComputePass();
let bindGroup106 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 187, resource: sampler13},
    {binding: 202, resource: {buffer: buffer97, size: 528}},
    {binding: 84, resource: {buffer: buffer97, size: 968}},
    {binding: 244, resource: {buffer: buffer1}},
    {binding: 181, resource: textureView67},
    {binding: 7, resource: sampler13},
    {binding: 38, resource: textureView37},
    {binding: 18, resource: {buffer: buffer38}},
    {binding: 3, resource: {buffer: buffer28, offset: 0, size: 252}},
    {binding: 5, resource: textureView70},
    {binding: 1, resource: {buffer: buffer76}},
    {binding: 0, resource: textureView39},
    {binding: 159, resource: {buffer: buffer98}},
    {binding: 93, resource: {buffer: buffer120}},
  ],
});
let textureView168 = texture32.createView({});
try {
computePassEncoder21.setBindGroup(1, bindGroup29);
} catch {}
try {
renderPassEncoder26.draw(1, 12, 0, 408_333_625);
} catch {}
try {
renderPassEncoder26.drawIndexed(3, 590, 2, -2_133_266_817, 246_168_971);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer34, 4);
} catch {}
try {
renderBundleEncoder31.drawIndexedIndirect(buffer124, 180);
} catch {}
try {
renderBundleEncoder31.drawIndirect(buffer124, 224);
} catch {}
try {
gpuCanvasContext6.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'srgb'});
} catch {}
let commandEncoder165 = device0.createCommandEncoder();
let texture192 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  format: 'astc-6x6-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let texture193 = gpuCanvasContext1.getCurrentTexture();
let textureView169 = texture3.createView({dimension: '2d', baseArrayLayer: 8});
try {
renderPassEncoder29.executeBundles([renderBundle14]);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer0, 'uint32', 0, 0);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline7);
} catch {}
try {
commandEncoder106.resolveQuerySet(querySet2, 1, 0, buffer19, 0);
} catch {}
let texture194 = device1.createTexture({
  size: {width: 6, height: 60, depthOrArrayLayers: 66},
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView170 = texture194.createView({baseArrayLayer: 10, arrayLayerCount: 6});
try {
buffer126.unmap();
} catch {}
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 24,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 70,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '3d' },
    },
  ],
});
let bindGroup107 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 2, resource: {buffer: buffer74, size: 24}},
    {binding: 3, resource: {buffer: buffer87}},
    {binding: 1, resource: externalTexture7},
    {binding: 90, resource: textureView57},
    {binding: 0, resource: textureView0},
  ],
});
let buffer128 = device0.createBuffer({size: 60, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture195 = device0.createTexture({
  size: {width: 2976, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder29.setBindGroup(0, bindGroup85);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder31.insertDebugMarker('\u0587');
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'unspecified'} });
let textureView171 = texture72.createView({dimension: '1d', baseMipLevel: 0, baseArrayLayer: 0});
try {
renderPassEncoder12.setBindGroup(0, bindGroup66, new Uint32Array(1017), 187, 1);
} catch {}
try {
renderPassEncoder4.draw(9, 0, 323_054_162);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer61, 36);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer77, 'uint16', 8, 13);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer17, 'uint32', 8, 22);
} catch {}
try {
buffer17.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer17, 4, new Float32Array(3699).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6332)), 852, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture196 = device0.createTexture({
  size: {width: 372, height: 1, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView172 = texture99.createView({});
try {
renderPassEncoder12.setBindGroup(2, bindGroup36);
} catch {}
try {
renderPassEncoder4.draw(225, 0, 232_446_311);
} catch {}
try {
renderPassEncoder4.drawIndexed(1, 0, 0, 121_900_585);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer105, 4);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(0, buffer13);
} catch {}
try {
commandEncoder104.copyTextureToTexture({
  texture: texture99,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture96,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 2},
  aspect: 'all',
},
{width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup108 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [{binding: 230, resource: textureView10}, {binding: 10, resource: sampler6}],
});
let textureView173 = texture33.createView({dimension: '2d-array', mipLevelCount: 1});
let texture197 = device0.createTexture({
  size: [408, 1, 254],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView174 = texture53.createView({format: 'r32float'});
let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['rg11b10ufloat'], sampleCount: 4});
try {
computePassEncoder21.setBindGroup(2, bindGroup40);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 110, 0, -2_085_480_880, 102_785_651);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline29);
} catch {}
let pipeline33 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule2, entryPoint: 'compute1'}});
let textureView175 = texture190.createView({baseArrayLayer: 1, arrayLayerCount: 60});
try {
computePassEncoder39.pushDebugGroup('\u89e5');
} catch {}
try {
device1.queue.writeTexture({
  texture: texture190,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 6},
  aspect: 'stencil-only',
}, new Uint8Array(8_666).fill(162), /* required buffer size: 8_666 */
{offset: 83, bytesPerRow: 39, rowsPerImage: 110}, {width: 3, height: 1, depthOrArrayLayers: 3});
} catch {}
document.body.append(img1);
let commandEncoder166 = device1.createCommandEncoder({});
let textureView176 = texture188.createView({dimension: '2d', baseArrayLayer: 6, arrayLayerCount: 1});
let textureView177 = texture194.createView({dimension: '2d', baseArrayLayer: 28});
let veryExplicitBindGroupLayout17 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let bindGroup109 = device1.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 1, resource: textureView176}]});
let pipelineLayout4 = device1.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout17, veryExplicitBindGroupLayout17, veryExplicitBindGroupLayout17, veryExplicitBindGroupLayout17],
});
let texture198 = device1.createTexture({
  size: [300, 43, 30],
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 60, depthOrArrayLayers: 66}
*/
{
  source: imageData14,
  origin: { x: 2, y: 19 },
  flipY: false,
}, {
  texture: texture194,
  mipLevel: 0,
  origin: {x: 0, y: 11, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(23); };
} catch {}
let buffer129 = device0.createBuffer({size: 92, usage: GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder26.drawIndexed(13, 1, 6, 188_538_405);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer34, 0);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(6, buffer51);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let commandEncoder167 = device0.createCommandEncoder({});
let texture199 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 20},
  format: 'astc-8x8-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder16.setBindGroup(0, bindGroup33, new Uint32Array(4110), 934, 0);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 191, 0, 269_388_477, 1_657_785_076);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, buffer37, 0, 14);
} catch {}
try {
renderBundleEncoder31.draw(0, 0);
} catch {}
try {
  await promise19;
} catch {}
let sampler29 = device1.createSampler({addressModeU: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 37.66, compare: 'less-equal'});
let renderPassEncoder34 = commandEncoder166.beginRenderPass({
  colorAttachments: [{
  view: textureView177,
  clearValue: { r: 706.5, g: -957.9, b: -969.5, a: 246.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder34.setBindGroup(3, bindGroup109, []);
} catch {}
let buffer130 = device0.createBuffer({
  size: 120,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView178 = texture80.createView({dimension: '2d'});
let computePassEncoder40 = commandEncoder121.beginComputePass();
let renderBundle17 = renderBundleEncoder31.finish({});
try {
computePassEncoder8.setBindGroup(1, bindGroup99, new Uint32Array(1225), 185, 0);
} catch {}
try {
renderPassEncoder31.setBindGroup(2, bindGroup40, []);
} catch {}
try {
renderPassEncoder4.draw(35, 0, 415_775_887);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 25, 0, 866_164_936, 1_047_225_258);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer32, 'uint16', 22, 7);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup53);
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
let pipeline34 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment3',
  targets: [{
  format: 'r16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule6,
    constants: {},
    buffers: [
      {
        arrayStride: 24,
        attributes: [
          {format: 'uint32', offset: 4, shaderLocation: 7},
          {format: 'sint8x2', offset: 2, shaderLocation: 15},
          {format: 'unorm16x2', offset: 4, shaderLocation: 9},
          {format: 'sint8x4', offset: 0, shaderLocation: 0},
          {format: 'snorm16x2', offset: 4, shaderLocation: 8},
          {format: 'sint32x2', offset: 0, shaderLocation: 11},
          {format: 'sint32', offset: 0, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x2', offset: 10, shaderLocation: 4}],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
let buffer131 = device1.createBuffer({size: 104, usage: GPUBufferUsage.STORAGE});
let commandEncoder168 = device1.createCommandEncoder({});
let texture200 = device1.createTexture({
  size: {width: 150, height: 21, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView179 = texture188.createView({format: 'depth32float-stencil8', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 29});
try {
renderPassEncoder34.setBindGroup(0, bindGroup109);
} catch {}
try {
commandEncoder163.insertDebugMarker('\u{1f89e}');
} catch {}
let promise21 = device1.queue.onSubmittedWorkDone();
try {
gpuCanvasContext5.unconfigure();
} catch {}
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'logSqrt'} });
try {
globalThis.someLabel = renderBundleEncoder18.label;
} catch {}
let texture201 = device0.createTexture({
  size: [1172],
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView180 = texture51.createView({});
try {
computePassEncoder9.setBindGroup(2, bindGroup28, [0]);
} catch {}
try {
computePassEncoder40.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder26.drawIndexed(3, 1, 0, 2_147_483_647, 0);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer105, 0);
} catch {}
try {
buffer113.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 11}
*/
{
  source: videoFrame13,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 15, y: 13, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let shaderModule7 = device1.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

requires packed_4x8_integer_dot_product;

struct T2 {
  f0: array<u32>,
}

struct T1 {
  @size(64) f0: f16,
  @size(960) f1: array<f16, 30>,
  @size(128) f2: array<vec2f, 1>,
  @size(64) f3: array<vec4f, 1>,
  f4: array<array<array<f32, 32>, 1>, 1>,
  @size(64) f5: array<array<vec2i, 1>, 1>,
  @size(448) f6: vec4f,
  f7: array<array<array<array<array<bool, 1>, 1>, 1>, 80>, 1>,
  @size(2112) f8: array<i32, 1>,
  @size(832) f9: array<u32, 104>,
  f10: array<u32, 80>,
  @size(64) f11: array<vec4h, 1>,
  @size(2816) f12: array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 78>,
  @size(128) f13: f16,
  @align(64) @size(832) f14: i32,
}

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

var<workgroup> vw9: T0;

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

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

@id(46945) override override14 = 0.2156e-3;

struct T7 {
  @align(16) @size(16) f0: array<atomic<u32>, 1>,
}

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

struct T3 {
  @size(200) f0: atomic<i32>,
  f1: array<vec2i>,
}

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

var<private> vp15: ComputeInput5 = ComputeInput5();

override override20 = 0.00757;

struct T0 {
  @size(76) f0: atomic<i32>,
}

@id(2847) override override13: f32;

override override15: bool;

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

@id(59249) override override17: u32;

override override18 = false;

struct T8 {
  f0: array<u32>,
}

override override12: f16 = 3690.1;

override override19: i32 = 729376101;

var<workgroup> vw8: ComputeInput5;

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

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

struct T6 {
  f0: i32,
  f1: T5,
}

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

var<workgroup> vw7: T7;

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

override override16: bool;

var<private> vp14 = frexp(f16(-4339.5));

alias vec3b = vec3<bool>;

/* used global variables: tex1 */
@compute @workgroup_size(4, 1, 1)
fn compute5(@builtin(local_invocation_id) local_invocation_id: vec3u, a1: ComputeInput5, @builtin(local_invocation_index) local_invocation_index: u32, a3: ComputeInput6, @builtin(workgroup_id) workgroup_id: vec3u) {
  let vf47: u32 = atomicLoad(&(*&vw7).f0[unconst_u32(319721972)]);
  let vf48: vec3f = acosh(vec3f(unconst_f32(0.4077), unconst_f32(0.3168), unconst_f32(-0.07525)));
  atomicExchange(&vw7.f0[unconst_u32(688699147)], unconst_u32(641824505));
  vp14.exp ^= i32(sqrt(unconst_f32(0.7171)));
  atomicMin(&vw9.f0, unconst_i32(124236135));
  vp15.num_workgroups &= vec3u(vec3u(unconst_u32(865036430), unconst_u32(38734748), unconst_u32(1707905713)));
  return;
  _ = tex1;
}`,
});
let buffer132 = device1.createBuffer({size: 92, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder169 = device1.createCommandEncoder({});
let texture202 = device1.createTexture({
  size: [1200, 174, 1],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder41 = commandEncoder168.beginComputePass();
let renderBundleEncoder34 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], stencilReadOnly: true});
try {
computePassEncoder39.setBindGroup(0, bindGroup109, new Uint32Array(401), 13, 0);
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup109);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer132, 'uint32', 84, 0);
} catch {}
try {
renderBundleEncoder34.setBindGroup(2, bindGroup109, new Uint32Array(1823), 791, 0);
} catch {}
try {
renderBundleEncoder34.setIndexBuffer(buffer132, 'uint16', 0, 4);
} catch {}
try {
computePassEncoder39.popDebugGroup();
} catch {}
let bindGroup110 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 1, resource: externalTexture20},
    {binding: 90, resource: textureView57},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 2, resource: {buffer: buffer10}},
    {binding: 0, resource: textureView51},
  ],
});
let computePassEncoder42 = commandEncoder107.beginComputePass();
let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['r16uint']});
try {
computePassEncoder42.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup88, new Uint32Array(479), 130, 1);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer92, 'uint16', 12, 119);
} catch {}
try {
device0.queue.writeBuffer(buffer17, 16, new Float16Array(7015).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.604)), 311, 4);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let img4 = await imageWithData(109, 132, '#10101010', '#20202020');
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'smpte170m'} });
let buffer133 = device1.createBuffer({
  size: 52,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture203 = device1.createTexture({
  size: {width: 600, height: 87, depthOrArrayLayers: 43},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView181 = texture189.createView({mipLevelCount: 1});
let computePassEncoder43 = commandEncoder169.beginComputePass();
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 60, depthOrArrayLayers: 66}
*/
{
  source: imageData2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture194,
  mipLevel: 0,
  origin: {x: 2, y: 10, z: 7},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup111 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 2, resource: {buffer: buffer62, size: 52}}],
});
try {
computePassEncoder21.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder26.draw(89, 1, 232_110_719);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(7, buffer13, 0, 0);
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
let commandEncoder170 = device0.createCommandEncoder({});
let textureView182 = texture184.createView({});
let computePassEncoder44 = commandEncoder112.beginComputePass();
try {
computePassEncoder15.setBindGroup(0, bindGroup56);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline25);
} catch {}
try {
computePassEncoder44.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder30.setPipeline(pipeline34);
} catch {}
try {
buffer57.unmap();
} catch {}
try {
commandEncoder138.copyTextureToTexture({
  texture: texture123,
  mipLevel: 1,
  origin: {x: 156, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture138,
  mipLevel: 0,
  origin: {x: 64, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2976, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData14,
  origin: { x: 24, y: 75 },
  flipY: false,
}, {
  texture: texture150,
  mipLevel: 0,
  origin: {x: 233, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let imageData23 = new ImageData(68, 160);
let bindGroup112 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 571, resource: textureView65},
    {binding: 44, resource: {buffer: buffer40}},
    {binding: 11, resource: sampler13},
    {binding: 146, resource: textureView162},
    {binding: 337, resource: {buffer: buffer11, offset: 0}},
    {binding: 252, resource: textureView148},
    {binding: 139, resource: textureView63},
    {binding: 2, resource: externalTexture10},
    {binding: 0, resource: textureView105},
    {binding: 153, resource: sampler21},
    {binding: 29, resource: {buffer: buffer120}},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 8, resource: {buffer: buffer54}},
    {binding: 1, resource: {buffer: buffer120, offset: 2304}},
    {binding: 239, resource: textureView62},
    {binding: 303, resource: {buffer: buffer11}},
    {binding: 43, resource: sampler22},
    {binding: 52, resource: textureView61},
    {binding: 238, resource: {buffer: buffer0, size: 4}},
    {binding: 15, resource: externalTexture21},
  ],
});
try {
computePassEncoder16.setBindGroup(0, bindGroup18, new Uint32Array(1510), 688, 1);
} catch {}
try {
renderPassEncoder12.end();
} catch {}
try {
renderPassEncoder23.beginOcclusionQuery(64);
} catch {}
try {
renderPassEncoder23.draw(1, 62, 0, 288_016_924);
} catch {}
try {
renderPassEncoder4.drawIndexed(1, 0, 0, 374_332_970);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer101, 72);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer86);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer2, 3_692, 4_229);
} catch {}
try {
renderPassEncoder22.insertDebugMarker('\u{1ff36}');
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 105, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas3,
  origin: { x: 17, y: 12 },
  flipY: false,
}, {
  texture: texture56,
  mipLevel: 0,
  origin: {x: 11, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 21, height: 54, depthOrArrayLayers: 0});
} catch {}
let sampler30 = device1.createSampler({
  label: '\u{1fd15}\u09e6\u0808\u{1fe87}\ua369',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.76,
  maxAnisotropy: 6,
});
let texture204 = device1.createTexture({
  size: [6],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView183 = texture200.createView({dimension: '2d-array'});
let computePassEncoder45 = commandEncoder163.beginComputePass();
try {
computePassEncoder43.setBindGroup(1, bindGroup109);
} catch {}
try {
computePassEncoder39.setBindGroup(3, bindGroup109, new Uint32Array(1398), 139, 0);
} catch {}
let veryExplicitBindGroupLayout18 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 31,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {binding: 47, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {binding: 53, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 23, hasDynamicOffset: false },
    },
    {
      binding: 114,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 154, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 202,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 445,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 523,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 775,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let buffer134 = device1.createBuffer({size: 172, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let texture205 = device1.createTexture({
  size: {width: 1200},
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder36 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder36.setVertexBuffer(3, buffer134, 4, 42);
} catch {}
let buffer135 = device1.createBuffer({size: 160, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let texture206 = device1.createTexture({
  size: {width: 300, height: 43, depthOrArrayLayers: 58},
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture207 = device1.createTexture({
  size: [1, 15, 272],
  sampleCount: 1,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture26 = device1.importExternalTexture({source: videoFrame22});
try {
renderPassEncoder34.setBindGroup(2, bindGroup109, []);
} catch {}
try {
  await promise21;
} catch {}
let texture208 = device0.createTexture({
  size: {width: 293, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder26.draw(123, 1, 55_157_109);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer93, 'uint16', 10, 60);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, buffer1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 816, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup113 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 3, resource: {buffer: buffer1}}, {binding: 2, resource: {buffer: buffer76, offset: 0}}],
});
let commandEncoder171 = device0.createCommandEncoder();
try {
renderPassEncoder11.drawIndexed(0, 236, 0, 1_938_168_094, 466_964_176);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer21, 4);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 11}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let imageData24 = new ImageData(72, 88);
let pipelineLayout5 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout17]});
let commandEncoder172 = device1.createCommandEncoder({});
let textureView184 = texture202.createView({label: '\u{1ff6c}\u{1f8b3}\u87d6\uf16f\u{1fbaf}'});
let textureView185 = texture207.createView({format: 'rg16float'});
try {
renderBundleEncoder36.setIndexBuffer(buffer132, 'uint16', 10, 19);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
  await promise18;
} catch {}
let texture209 = device1.createTexture({
  size: {width: 600, height: 87, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder46 = commandEncoder172.beginComputePass();
try {
renderPassEncoder34.setBlendConstant({ r: -548.7, g: 111.2, b: 39.10, a: -43.18, });
} catch {}
try {
renderPassEncoder34.setVertexBuffer(4, buffer134, 0, 21);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer135, 'uint32', 12, 35);
} catch {}
try {
device1.queue.writeBuffer(buffer133, 0, new Uint32Array(7778).map((_, i) => i * 10), 3621, 0);
} catch {}
let sampler31 = device1.createSampler({addressModeW: 'repeat', lodMaxClamp: 94.03, compare: 'greater-equal'});
let renderBundleEncoder37 = device1.createRenderBundleEncoder({colorFormats: ['rg16float']});
try {
gpuCanvasContext5.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 150, height: 21, depthOrArrayLayers: 1}
*/
{
  source: videoFrame19,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture200,
  mipLevel: 0,
  origin: {x: 118, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup114 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 0, resource: textureView157},
    {binding: 153, resource: sampler28},
    {binding: 43, resource: sampler13},
    {binding: 15, resource: externalTexture5},
    {binding: 11, resource: sampler1},
    {binding: 146, resource: textureView157},
    {binding: 2, resource: externalTexture21},
    {binding: 303, resource: {buffer: buffer97, size: 1036}},
    {binding: 3, resource: {buffer: buffer11}},
    {binding: 52, resource: textureView61},
    {binding: 8, resource: {buffer: buffer125}},
    {binding: 238, resource: {buffer: buffer117}},
    {binding: 139, resource: textureView74},
    {binding: 252, resource: textureView84},
    {binding: 29, resource: {buffer: buffer120}},
    {binding: 571, resource: textureView73},
    {binding: 1, resource: {buffer: buffer120}},
    {binding: 44, resource: {buffer: buffer0, size: 4}},
    {binding: 239, resource: textureView62},
    {binding: 337, resource: {buffer: buffer120}},
  ],
});
let texture210 = device0.createTexture({
  size: {width: 102, height: 1, depthOrArrayLayers: 1},
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture211 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder32.setBindGroup(3, bindGroup25);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline30);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup41, new Uint32Array(146), 2, 0);
} catch {}
try {
renderPassEncoder26.draw(134, 1, 209_267_294, 0);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(6, buffer22);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(0, buffer30);
} catch {}
let bindGroup115 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 2, resource: {buffer: buffer97, size: 124}}],
});
let texture212 = device0.createTexture({size: [2976], dimension: '1d', format: 'rg11b10ufloat', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder9.setBindGroup(0, bindGroup102);
} catch {}
try {
renderPassEncoder23.drawIndirect(buffer106, 8);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer105, 4);
} catch {}
try {
commandEncoder86.copyTextureToBuffer({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 259, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18624 widthInBlocks: 1164 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 144 */
  offset: 144,
  bytesPerRow: 40704,
  buffer: buffer53,
}, {width: 1164, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder146.pushDebugGroup('\u0638');
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\u84f7');
} catch {}
let veryExplicitBindGroupLayout19 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 31,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {binding: 47, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {binding: 53, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 23, hasDynamicOffset: false },
    },
    {
      binding: 114,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 154, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 202,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 445,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 523,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 775,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let pipelineLayout6 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout19, veryExplicitBindGroupLayout17]});
let textureView186 = texture205.createView({aspect: 'all', baseArrayLayer: 0});
try {
renderPassEncoder34.setBindGroup(1, bindGroup109, new Uint32Array(1533), 121, 0);
} catch {}
try {
renderBundleEncoder37.setIndexBuffer(buffer132, 'uint16', 4, 2);
} catch {}
try {
device1.pushErrorScope('out-of-memory');
} catch {}
let texture213 = device1.createTexture({
  size: {width: 1200, height: 174, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture214 = device1.createTexture({
  size: [1200, 174, 1],
  mipLevelCount: 9,
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView187 = texture203.createView({dimension: '2d', baseArrayLayer: 11});
try {
computePassEncoder39.setBindGroup(2, bindGroup109, new Uint32Array(3307), 107, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer134, 4, new BigInt64Array(11314).map((_, i) => BigInt(i - 2)), 705, 0);
} catch {}
let buffer136 = device0.createBuffer({size: 76, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder173 = device0.createCommandEncoder({});
let textureView188 = texture139.createView({});
try {
renderPassEncoder23.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup33);
} catch {}
try {
renderBundleEncoder32.setBindGroup(3, bindGroup115, new Uint32Array(973), 20, 0);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 2, 0, 10_707_959, 1);
} catch {}
try {
renderBundleEncoder17.drawIndexedIndirect(buffer72, 92);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer72, 204);
} catch {}
try {
renderBundleEncoder35.setIndexBuffer(buffer103, 'uint16', 22, 39);
} catch {}
await gc();
let texture215 = device1.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 29},
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView189 = texture215.createView({dimension: 'cube-array', baseArrayLayer: 10, arrayLayerCount: 6});
try {
renderPassEncoder34.setBindGroup(1, bindGroup109, new Uint32Array(945), 23, 0);
} catch {}
let bindGroup116 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [
    {binding: 8, resource: {buffer: buffer97, offset: 0, size: 168}},
    {binding: 407, resource: {buffer: buffer124, offset: 0}},
    {binding: 0, resource: {buffer: buffer76}},
    {binding: 11, resource: textureView38},
    {binding: 3, resource: textureView53},
    {binding: 5, resource: textureView108},
  ],
});
let buffer137 = device0.createBuffer({size: 80, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let commandEncoder174 = device0.createCommandEncoder({label: '\ubf49\u{1fdc6}\u22ae\u06b0\uae2f\u049d\ua556\u17a7\u0d56\u{1fea7}'});
let texture216 = device0.createTexture({
  size: [180, 105, 530],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder38.setBindGroup(0, bindGroup19);
} catch {}
try {
computePassEncoder23.setBindGroup(3, bindGroup38, new Uint32Array(262), 70, 0);
} catch {}
try {
renderPassEncoder22.end();
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer124, 20);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer21, 8);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(2, buffer97, 12, 51);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup76, new Uint32Array(29), 1, 0);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(1, buffer128);
} catch {}
try {
commandEncoder86.copyBufferToBuffer(buffer17, 0, buffer99, 8, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer97, 168, new Float16Array(20442).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.3441)), 6065, 28);
} catch {}
let renderBundleEncoder38 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], sampleCount: 1, depthReadOnly: true});
try {
renderPassEncoder32.setBindGroup(0, bindGroup19, new Uint32Array(3136), 92, 0);
} catch {}
try {
renderPassEncoder11.draw(0, 133, 0, 254_798_069);
} catch {}
try {
renderPassEncoder23.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup38, new Uint32Array(1895), 313, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer110, 24, new DataView(new ArrayBuffer(8952)), 1308, 4);
} catch {}
try {
  await promise22;
} catch {}
let buffer138 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder175 = device0.createCommandEncoder();
let textureView190 = texture143.createView({dimension: '2d-array'});
try {
renderPassEncoder11.draw(0, 146, 0, 71_979_395);
} catch {}
try {
renderPassEncoder4.drawIndexed(1, 0, 0, 851_513_459);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 2, 0, 560_753_407);
} catch {}
try {
renderBundleEncoder27.drawIndirect(buffer77, 0);
} catch {}
try {
buffer66.unmap();
} catch {}
try {
commandEncoder118.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1620 */
  offset: 1620,
  buffer: buffer2,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 88, y: 0, z: 0},
  aspect: 'all',
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise23 = adapter2.requestDevice({
  defaultQueue: {},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
    'timestamp-query',
  ],
});
let textureView191 = texture206.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 3});
let renderBundleEncoder39 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: false, stencilReadOnly: true});
try {
computePassEncoder45.setBindGroup(0, bindGroup109, []);
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup109, new Uint32Array(966), 25, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer133, 4, new Float32Array(2975).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.5226)), 618, 0);
} catch {}
let offscreenCanvas6 = new OffscreenCanvas(266, 153);
let texture217 = device0.createTexture({size: {width: 408}, dimension: '1d', format: 'rg11b10ufloat', usage: GPUTextureUsage.TEXTURE_BINDING});
let renderBundle18 = renderBundleEncoder27.finish({});
try {
computePassEncoder17.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder4.draw(93, 0, 335_603_889);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer61, 8);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer102, 16);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup116, [0]);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 1, 0, 74_674_609);
} catch {}
try {
device0.queue.writeBuffer(buffer66, 0, new Float16Array(306).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.534)), 85, 0);
} catch {}
let imageData25 = new ImageData(32, 48);
let commandEncoder176 = device1.createCommandEncoder({});
let texture218 = device1.createTexture({
  size: [600, 87, 1],
  mipLevelCount: 5,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder35 = commandEncoder176.beginRenderPass({
  colorAttachments: [{
  view: textureView185,
  depthSlice: 31,
  clearValue: { r: 189.9, g: -276.5, b: -156.5, a: -501.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder34.setIndexBuffer(buffer132, 'uint32', 0, 3);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let texture219 = device1.createTexture({
  label: '\u54a1\u0b7b\u1218\u{1fef5}\u{1fd02}\u{1fd24}\u0ad9\u{1ffe7}',
  size: [16, 16, 192],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView192 = texture214.createView({mipLevelCount: 1});
try {
renderPassEncoder35.setIndexBuffer(buffer132, 'uint32', 0, 11);
} catch {}
try {
  await promise17;
} catch {}
let commandBuffer28 = commandEncoder66.finish();
try {
renderPassEncoder23.draw(1, 101, 0, 1_498_515_963);
} catch {}
try {
renderPassEncoder23.drawIndexed(3, 13, 6, -1_960_061_766, 2_942_225_271);
} catch {}
try {
renderPassEncoder23.drawIndexedIndirect(buffer40, 64);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer29, 12);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer22, 0, 29);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup6, new Uint32Array(192), 41, 0);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer77, 60);
} catch {}
try {
commandEncoder89.clearBuffer(buffer110, 4, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder177 = device0.createCommandEncoder({});
let texture220 = device0.createTexture({
  size: {width: 816},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView193 = texture96.createView({baseArrayLayer: 0});
let externalTexture27 = device0.importExternalTexture({source: videoFrame25, colorSpace: 'display-p3'});
try {
renderPassEncoder26.drawIndexed(3, 1, 1, 145_956_354);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline29);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(1, buffer11, 440);
} catch {}
try {
renderBundleEncoder29.setBindGroup(2, bindGroup6);
} catch {}
try {
renderBundleEncoder13.draw(0, 559, 0, 1_486_019_419);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 1, 0, -1_678_408_796, 0);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline23);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup117 = device1.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 1, resource: textureView176}]});
let commandEncoder178 = device1.createCommandEncoder({});
let textureView194 = texture203.createView({format: 'rg32float', baseArrayLayer: 0, arrayLayerCount: 2});
let computePassEncoder47 = commandEncoder178.beginComputePass();
try {
computePassEncoder45.setBindGroup(0, bindGroup117, new Uint32Array(130), 99, 0);
} catch {}
try {
renderPassEncoder34.setBindGroup(2, bindGroup109, new Uint32Array(1023), 216, 0);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(7, buffer135, 28);
} catch {}
try {
device1.queue.writeBuffer(buffer133, 4, new Float32Array(40573).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.953)), 2427, 0);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let commandEncoder179 = device1.createCommandEncoder({});
let renderPassEncoder36 = commandEncoder179.beginRenderPass({
  colorAttachments: [{
  view: textureView185,
  depthSlice: 188,
  clearValue: { r: 992.7, g: -349.6, b: 98.83, a: -828.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder36.setBindGroup(2, bindGroup117, new Uint32Array(2592), 488, 0);
} catch {}
let commandEncoder180 = device0.createCommandEncoder();
let texture221 = device0.createTexture({
  size: [744, 3, 1],
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '2d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView195 = texture118.createView({});
try {
renderPassEncoder11.drawIndexed(0, 783, 0, -1_545_585_605, 629_763_229);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer39, 68);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer71, 0);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup88, new Uint32Array(1014), 16, 1);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 1, 0, -2_026_656_058);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline9);
} catch {}
try {
commandEncoder146.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer28]);
} catch {}
let imageData26 = new ImageData(4, 12);
let textureView196 = texture205.createView({});
let renderBundleEncoder40 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
let sampler32 = device1.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 97.14});
try {
device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); });
} catch {}
let renderBundleEncoder41 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: false, stencilReadOnly: true});
try {
renderBundleEncoder41.setVertexBuffer(0, buffer134, 0);
} catch {}
try {
renderPassEncoder34.insertDebugMarker('\u37ff');
} catch {}
try {
device1.queue.writeBuffer(buffer134, 136, new DataView(new Uint8Array(1295).map((_, i) => i).buffer), 166, 0);
} catch {}
try {
  await promise20;
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt709', transfer: 'iec6196624'} });
try {
adapter2.label = '\u1734\u0b61\u22ac\u899b\udcbf\u0459';
} catch {}
let textureView197 = texture13.createView({dimension: '2d-array', baseMipLevel: 0, arrayLayerCount: 1});
document.body.prepend(img2);
let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'film', transfer: 'gamma28curve'} });
let commandEncoder181 = device1.createCommandEncoder({});
let texture222 = device1.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 19},
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder37 = commandEncoder181.beginRenderPass({
  colorAttachments: [{
  view: textureView177,
  clearValue: { r: -544.0, g: -36.69, b: 949.3, a: 739.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 882829282,
});
try {
computePassEncoder39.setBindGroup(3, bindGroup117);
} catch {}
try {
computePassEncoder47.end();
} catch {}
try {
renderPassEncoder37.setVertexBuffer(6, buffer135, 76, 17);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
document.body.prepend(img0);
let computePassEncoder48 = commandEncoder178.beginComputePass();
let renderBundleEncoder42 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true});
try {
renderBundleEncoder39.setBindGroup(0, bindGroup109, new Uint32Array(3958), 280, 0);
} catch {}
let gpuCanvasContext8 = offscreenCanvas6.getContext('webgpu');
let imageData27 = new ImageData(104, 8);
let commandEncoder182 = device1.createCommandEncoder({});
try {
computePassEncoder45.setBindGroup(2, bindGroup117, new Uint32Array(1241), 126, 0);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer132, 'uint16', 42, 5);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(62); };
} catch {}
let commandEncoder183 = device0.createCommandEncoder({});
let textureView198 = texture157.createView({});
try {
renderPassEncoder26.drawIndexedIndirect(buffer78, 0);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer120, 3_460);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer109, 'uint16', 70, 38);
} catch {}
let pipeline35 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule6, constants: {}}});
let buffer139 = device1.createBuffer({size: 72, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder184 = device1.createCommandEncoder({});
try {
renderPassEncoder36.end();
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer139, 'uint32', 0, 2);
} catch {}
try {
renderBundleEncoder40.setIndexBuffer(buffer132, 'uint32', 8, 4);
} catch {}
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, recycledExplicitBindGroupLayout5]});
let commandEncoder185 = device0.createCommandEncoder({label: '\u27ef\ucb7d\u{1fd1e}\u09f2\ueeb3\u0277\u{1ff92}\u0021'});
let texture223 = device0.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder32.setBindGroup(1, bindGroup32);
} catch {}
try {
computePassEncoder36.setBindGroup(2, bindGroup96, new Uint32Array(567), 64, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup80, [0]);
} catch {}
try {
renderPassEncoder26.setBindGroup(1, bindGroup25, new Uint32Array(2008), 217, 0);
} catch {}
try {
renderPassEncoder11.draw(0, 182, 0, 83_820_025);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer10, 0);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(5, buffer9, 72);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup70);
} catch {}
try {
renderBundleEncoder30.setBindGroup(1, bindGroup18, new Uint32Array(1716), 160, 1);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 4, 0, 374_773_448);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline6);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'bt709'} });
let bindGroup118 = device0.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 2, resource: {buffer: buffer87}}]});
let commandEncoder186 = device0.createCommandEncoder();
try {
renderPassEncoder31.beginOcclusionQuery(1106);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer138, 28);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer0, 'uint32', 0, 2);
} catch {}
try {
renderBundleEncoder17.draw(220, 1, 484_021_487);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer18, 4);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(0, buffer128);
} catch {}
let offscreenCanvas7 = new OffscreenCanvas(542, 65);
let commandEncoder187 = device1.createCommandEncoder();
let computePassEncoder49 = commandEncoder182.beginComputePass();
try {
renderPassEncoder34.setIndexBuffer(buffer135, 'uint16', 72, 0);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let buffer140 = device1.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder188 = device1.createCommandEncoder({});
let renderPassEncoder38 = commandEncoder184.beginRenderPass({colorAttachments: [{view: textureView185, depthSlice: 137, loadOp: 'clear', storeOp: 'store'}]});
try {
renderPassEncoder35.setIndexBuffer(buffer132, 'uint32', 4, 11);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 300, height: 43, depthOrArrayLayers: 1}
*/
{
  source: videoFrame25,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture218,
  mipLevel: 1,
  origin: {x: 17, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer141 = device0.createBuffer({size: 76, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder189 = device0.createCommandEncoder({});
let textureView199 = texture20.createView({dimension: '2d-array'});
try {
renderPassEncoder26.setBlendConstant({ r: -613.5, g: 33.74, b: 172.0, a: 602.5, });
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer105, 4);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer38, 0);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(6, buffer0, 0, 0);
} catch {}
let commandEncoder190 = device0.createCommandEncoder({});
try {
renderPassEncoder31.endOcclusionQuery();
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 2, 0, 36_950_813, 1_443_277_719);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 2, 0, 499_216_974);
} catch {}
try {
buffer114.unmap();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder191 = device0.createCommandEncoder({});
let textureView200 = texture182.createView({dimension: '3d', baseMipLevel: 0, arrayLayerCount: 1});
let textureView201 = texture101.createView({});
try {
renderPassEncoder11.drawIndexedIndirect(buffer21, 40);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer39, 36);
} catch {}
try {
renderBundleEncoder13.draw(0, 104, 0, 267_175_990);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer106, 24);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer84, 'uint16', 22, 25);
} catch {}
let commandEncoder192 = device0.createCommandEncoder({});
let sampler33 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.81,
  compare: 'not-equal',
});
try {
computePassEncoder37.setBindGroup(3, bindGroup61, new Uint32Array(387), 26, 0);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer124, 76);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup13);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer39, 168);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer34, 44, new DataView(new ArrayBuffer(48784)), 4051, 4);
} catch {}
let gpuCanvasContext9 = offscreenCanvas7.getContext('webgpu');
let computePassEncoder50 = commandEncoder188.beginComputePass();
try {
renderBundleEncoder42.setBindGroup(3, bindGroup109);
} catch {}
try {
renderBundleEncoder40.setIndexBuffer(buffer132, 'uint32', 12, 2);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 60, depthOrArrayLayers: 66}
*/
{
  source: imageBitmap2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture194,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder39.setVertexBuffer(4, buffer135, 12);
} catch {}
try {
device1.queue.writeBuffer(buffer134, 20, new Uint32Array(16738).map((_, i) => i * 6), 418, 0);
} catch {}
let bindGroup119 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 0, resource: textureView0},
    {binding: 1, resource: externalTexture27},
    {binding: 90, resource: textureView57},
    {binding: 3, resource: {buffer: buffer54}},
    {binding: 2, resource: {buffer: buffer76}},
  ],
});
let buffer142 = device0.createBuffer({size: 120, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let textureView202 = texture54.createView({dimension: '2d', baseArrayLayer: 2});
try {
renderPassEncoder4.setBindGroup(0, bindGroup64);
} catch {}
try {
renderPassEncoder4.draw(24, 0, 927_660_838);
} catch {}
try {
renderPassEncoder26.drawIndexed(6, 1, 0, -1_848_653_332);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer103, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder17.drawIndexed(4, 5, 0, 13_362_248);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(0, buffer95, 0, 10);
} catch {}
try {
commandEncoder127.insertDebugMarker('\ubb2c');
} catch {}
let buffer143 = device0.createBuffer({size: 196, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let commandEncoder193 = device0.createCommandEncoder();
let textureView203 = texture168.createView({});
try {
renderPassEncoder26.draw(152, 1, 3_263_412);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer34, 120);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer124, 52);
} catch {}
try {
buffer74.unmap();
} catch {}
try {
computePassEncoder32.insertDebugMarker('\uc128');
} catch {}
let pipeline36 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {}}});
let commandEncoder194 = device1.createCommandEncoder({});
let renderBundleEncoder43 = device1.createRenderBundleEncoder({
  label: '\u0605\ua062\ue065\u3a11\u{1fa54}\u04e1\u{1f723}\u2754',
  colorFormats: ['rg16float'],
  depthReadOnly: true,
});
try {
renderBundleEncoder37.setVertexBuffer(1, buffer135, 8, 18);
} catch {}
let buffer144 = device1.createBuffer({size: 249, usage: GPUBufferUsage.INDIRECT});
let commandEncoder195 = device1.createCommandEncoder({});
let texture224 = device1.createTexture({
  size: [1200],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder38.setBindGroup(3, bindGroup109, new Uint32Array(1232), 17, 0);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(1, buffer133, 0, 8);
} catch {}
try {
renderBundleEncoder40.pushDebugGroup('\uade1');
} catch {}
let veryExplicitBindGroupLayout20 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 11,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let buffer145 = device1.createBuffer({size: 348, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder196 = device1.createCommandEncoder({});
let texture225 = device1.createTexture({
  size: {width: 3, height: 30, depthOrArrayLayers: 66},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture226 = device1.createTexture({size: [12], dimension: '1d', format: 'rg16float', usage: GPUTextureUsage.TEXTURE_BINDING});
let computePassEncoder51 = commandEncoder194.beginComputePass();
try {
computePassEncoder39.setBindGroup(2, bindGroup109, new Uint32Array(1053), 17, 0);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 75, height: 10, depthOrArrayLayers: 1}
*/
{
  source: videoFrame29,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture218,
  mipLevel: 3,
  origin: {x: 9, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img1);
await gc();
let textureView204 = texture224.createView({dimension: '1d'});
let texture227 = device1.createTexture({
  size: [1200, 174, 41],
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView205 = texture227.createView({dimension: '2d', format: 'rg16float', baseArrayLayer: 1});
try {
renderBundleEncoder37.setVertexBuffer(1, buffer134, 0, 3);
} catch {}
try {
commandEncoder196.insertDebugMarker('\ufbb2');
} catch {}
let buffer146 = device1.createBuffer({size: 432, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder197 = device1.createCommandEncoder({});
let texture228 = device1.createTexture({
  size: [1, 15, 66],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder48.setBindGroup(3, bindGroup117);
} catch {}
try {
renderPassEncoder35.setBindGroup(1, bindGroup117, new Uint32Array(1574), 5, 0);
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup117, new Uint32Array(56), 10, 0);
} catch {}
await gc();
let buffer147 = device1.createBuffer({size: 212, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture229 = device1.createTexture({
  size: [150, 21, 5],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let bindGroup120 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 0, resource: textureView0},
    {binding: 1, resource: externalTexture13},
    {binding: 3, resource: {buffer: buffer101}},
    {binding: 90, resource: textureView43},
    {binding: 2, resource: {buffer: buffer74, size: 20}},
  ],
});
let textureView206 = texture196.createView({});
try {
renderPassEncoder26.drawIndexed(8, 1, 0, -2_005_863_322);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer92, 'uint16', 4, 19);
} catch {}
try {
renderBundleEncoder13.draw(0, 74, 0, 597_760_569);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer72, 'uint32', 284, 121);
} catch {}
let imageData28 = new ImageData(36, 32);
try {
renderPassEncoder26.drawIndexed(7, 1, 0, 122_710_207);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer128, 12);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer138, 0);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer28, 'uint16', 64, 23);
} catch {}
try {
renderBundleEncoder17.drawIndexedIndirect(buffer61, 184);
} catch {}
try {
buffer78.unmap();
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 52, new DataView(new ArrayBuffer(38352)), 543, 0);
} catch {}
let textureView207 = texture228.createView({dimension: '2d', format: 'rgba8unorm', baseArrayLayer: 8});
let buffer148 = device0.createBuffer({size: 248, usage: GPUBufferUsage.INDIRECT});
let commandEncoder198 = device0.createCommandEncoder();
try {
device0.queue.writeTexture({
  texture: texture183,
  mipLevel: 1,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(261).fill(86), /* required buffer size: 261 */
{offset: 261, bytesPerRow: 411}, {width: 167, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule8 = device1.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

enable f16;

diagnostic(info, xyz);

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

struct FragmentOutput5 {
  @builtin(sample_mask) sample_mask: u32,
  @location(0) location_0: vec2f,
}

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

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

@group(0) @binding(1) var tex2: texture_depth_2d;

var<workgroup> vw10: f16;

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

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

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

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

/* used global variables: tex2 */
@vertex
fn vertex4(@location(9) location_9: vec2i) -> @builtin(position) vec4f {
  var out: vec4f;
  var vf49: vec4f = atan(vec4f(unconst_f32(0.2545), unconst_f32(0.1572), unconst_f32(0.2539), unconst_f32(0.1177)));
  var vf50: vec4f = unpack4x8snorm(unconst_u32(1038909761));
  _ = tex2;
  return out;
  _ = tex2;
}

/* zero global variables used */
@fragment
fn fragment5(a0: FragmentInput12) -> FragmentOutput5 {
  var out: FragmentOutput5;
  out.sample_mask ^= pack4x8unorm(unpack4x8snorm(unconst_u32(973888755)));
  out.sample_mask = u32(length(vec2h(unconst_f16(5747.5), unconst_f16(12754.2))));
  let vf51: vec4i = (vec4i(unconst_i32(2147483647), unconst_i32(435872131), unconst_i32(670648059), unconst_i32(-491902315)) >> vec4u(unconst_u32(230074596), unconst_u32(116514501), unconst_u32(441698829), unconst_u32(608871414)));
  out.sample_mask *= u32(distance(vec3h(unconst_f16(27630.0), unconst_f16(1683.0), unconst_f16(4025.8)), vec3h(unconst_f16(3808.9), unconst_f16(13781.0), unconst_f16(31001.8))));
  if bool(length(vec4h(unconst_f16(3336.9), unconst_f16(24124.7), unconst_f16(45401.5), unconst_f16(-30448.0)))) {
  out.location_0 += vec2f((vec4h(unconst_f16(24267.1), unconst_f16(21019.1), unconst_f16(4807.7), unconst_f16(6739.2)) >= vec4h(unconst_f16(8276.6), unconst_f16(16595.5), unconst_f16(4200.1), unconst_f16(9744.9))).rg);
}
  for (var it1=a0.sample_mask; it1<(bitcast<u32>(unpack4x8snorm(unconst_u32(855726542))[2]) & 0xfff); it1++) {
  switch a0.sample_mask { 
  default: {
  let vf52: vec2u = firstLeadingBit(vec2u(unconst_u32(978036395), unconst_u32(397120903)));
  out.location_0 = vec2f(bitcast<f32>(out.sample_mask));
}
case 2905249063: {
  let vf53: u32 = pack4xU8(vec4u(unconst_u32(888939714), unconst_u32(183574593), unconst_u32(629028546), unconst_u32(635172898)));
  out.sample_mask = countTrailingZeros(unconst_u32(632765364));
  out.location_0 = vec2f(out.location_0[unconst_u32(202012882)]);
}
case 2209077835: {
  let vf54: bool = (unconst_i32(261799388) == unconst_i32(375853428));
  switch bitcast<i32>(pack2x16unorm(vec2f(unconst_f32(0.00066), unconst_f32(0.2396)))) { 
  default: {
  out.location_0 = vec2f(bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.2108e-43), unconst_f32(0.05681), unconst_f32(0.03513), unconst_f32(0.3176e-13)))));
  var vf55: vec2f = unpack2x16float(pack4xU8(vec4u(unconst_u32(941060373), unconst_u32(25002801), unconst_u32(651384103), unconst_u32(622418009))));
  let vf56: u32 = pack4xI8Clamp(vec4i(unconst_i32(305330513), unconst_i32(18306154), unconst_i32(46583122), unconst_i32(125115401)));
}
case 947777966: {
  out.location_0 += vec2f(out.location_0[unconst_u32(516028638)]);
  let vf57: vec4f = ceil(vec4f(unconst_f32(-0.2470e4), unconst_f32(0.8720), unconst_f32(0.1865e23), unconst_f32(0.07502)));
  break;
}
  }
  out.sample_mask -= bitcast<u32>((mat2x2h(unconst_f16(7556.5), unconst_f16(6806.4), unconst_f16(4064.3), unconst_f16(3088.6)) * vec2h(f16(any(unconst_bool(true))))));
  var vf58: FragmentInput12 = a0;
}
  }
  out = FragmentOutput5(pack4xU8Clamp(clamp(vec4u(unconst_u32(403055992), unconst_u32(145404334), unconst_u32(507381632), unconst_u32(450440931)), vec4u(unconst_u32(988029632), unconst_u32(277073890), unconst_u32(172958850), unconst_u32(10807200)), vec4u(unconst_u32(159430302), unconst_u32(773756274), unconst_u32(98075477), unconst_u32(56315184)))), vec2f(clamp(vec4u(unconst_u32(403055992), unconst_u32(145404334), unconst_u32(507381632), unconst_u32(450440931)), vec4u(unconst_u32(988029632), unconst_u32(277073890), unconst_u32(172958850), unconst_u32(10807200)), vec4u(unconst_u32(159430302), unconst_u32(773756274), unconst_u32(98075477), unconst_u32(56315184))).yx));
  out.sample_mask -= pack2x16snorm(out.location_0);
  let vf59: u32 = max(unconst_u32(45411589), u32(distance(unconst_f32(0.1413), unconst_f32(0.2101e-36))));
  out = FragmentOutput5(bitcast<u32>(distance(unconst_f32(-0.1646e22), unconst_f32(-0.4030))), vec2f(distance(unconst_f32(-0.1646e22), unconst_f32(-0.4030))));
  let vf60: vec3i = select(vec3i(unconst_i32(1541887722), unconst_i32(150613979), unconst_i32(45257884)), vec3i(unconst_i32(183090455), unconst_i32(617634653), unconst_i32(25312077)), bool(max(bitcast<u32>(select(vec3i(unconst_i32(50935773), unconst_i32(372350029), unconst_i32(693539870)), vec3i(unconst_i32(83985000), unconst_i32(238766662), unconst_i32(181033744)), unconst_bool(true))[1]), unconst_u32(312710532))));
  return out;
}
  out.sample_mask &= vec3u(step(vec3h(unconst_f16(10429.0), unconst_f16(36786.0), unconst_f16(32631.9)), vec3h(unconst_f16(28238.8), unconst_f16(25891.7), unconst_f16(6787.5))).rbg)[0];
  return out;
}`,
});
let texture230 = device1.createTexture({size: [150, 21, 1], mipLevelCount: 2, format: 'rg16float', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder34.setVertexBuffer(3, buffer133, 0);
} catch {}
let buffer149 = device1.createBuffer({size: 60, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandBuffer29 = commandEncoder179.finish();
let textureView208 = texture190.createView({aspect: 'stencil-only', baseArrayLayer: 6, arrayLayerCount: 11});
try {
computePassEncoder45.setBindGroup(3, bindGroup117);
} catch {}
let textureView209 = texture157.createView({});
try {
computePassEncoder15.setBindGroup(0, bindGroup77);
} catch {}
try {
renderPassEncoder11.draw(0, 63, 0, 568_843_442);
} catch {}
try {
device0.queue.writeBuffer(buffer53, 92, new Float32Array(311).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.016)), 149, 0);
} catch {}
let imageData29 = new ImageData(28, 32);
let commandEncoder199 = device1.createCommandEncoder({});
let texture231 = device1.createTexture({
  size: {width: 12},
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView210 = texture219.createView({dimension: '3d'});
try {
renderPassEncoder34.setIndexBuffer(buffer132, 'uint32', 92);
} catch {}
try {
renderBundleEncoder37.setBindGroup(3, bindGroup117);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let shaderModule9 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

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

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

@group(0) @binding(3) var<storage, read> buffer151: array<array<array<array<f16, 7>, 4>, 1>>;

struct VertexInput17 {
  @builtin(instance_index) instance_index: u32,
  @location(5) @interpolate(flat, first) location_5: u32,
  @location(15) @interpolate(linear) location_15: f16,
  @location(10) @interpolate(perspective) location_10: f32,
  @location(12) @interpolate(flat, center) location_12: vec4h,
  @location(9) @interpolate(linear, first) location_9: vec2h,
}

struct VertexInput18 {
  @location(0) @interpolate(flat, sample) location_0: vec4u,
  @location(7) @interpolate(perspective, centroid) location_7: vec2f,
}

@id(60143) override override25: i32;

struct FragmentInput13 {
  @location(13) location_13: u32,
  @location(11) @interpolate(flat, centroid) location_11: vec2u,
}

struct T3 {
  f0: array<u32>,
}

override override26: i32;

struct T7 {
  f0: vec2u,
  f1: vec2h,
}

@group(1) @binding(90) var st25: texture_storage_2d<rgba16uint, write>;

struct T0 {
  f0: array<u32>,
}

override override30 = true;

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

@id(20744) override override23: u32 = (156764740 % 103) + 1;

struct VertexOutput4 {
  @location(9) @interpolate(linear, centroid) location_9: vec4h,
  @invariant @builtin(position) position: vec4f,
  @location(15) location_15: f16,
  @location(1) @interpolate(flat, first) location_1: vec2h,
  @location(6) location_6: vec2h,
}

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

struct T4 {
  @align(8) @size(16) f0: atomic<u32>,
  f1: T3,
}

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

@id(24251) override override29: u32 = (336894980 % 103) + 1;

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

@group(1) @binding(2) var<storage, read_write> buffer152: array<array<f16, 6>>;

alias vec3b = vec3<bool>;

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

var<private> vp16: vec2i = vec2i(514042190, -373662949);

struct T2 {
  @size(16) f0: vec2i,
}

@id(27269) override override24 = false;

var<private> vp17: ComputeInput9 = ComputeInput9();

struct VertexInput19 {
  @location(2) location_2: vec2f,
}

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

override override27: i32;

override override21: i32 = 95028295;

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

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

struct T5 {
  @align(8) f0: T1,
}

override override22: f32;

override override28: bool;

@group(0) @binding(90) var st23: texture_storage_2d<rgba16uint, write>;

struct FragmentOutput6 {
  @location(0) location_0: vec4u,
  @location(7) @interpolate(flat) location_7: i32,
}

struct T1 {
  f0: array<u32>,
}

/* zero global variables used */
@vertex @must_use
fn vertex5(@location(4) @interpolate(flat, first) location_4: vec2f, @location(14) @interpolate(flat, either) location_14: i32, a2: VertexInput17, @builtin(vertex_index) vertex_index: u32, @location(13) location_13: f32, @location(8) location_8: f16, @location(1) @interpolate(linear) location_1: f16, a7: VertexInput18, a8: VertexInput19, @location(6) location_6: vec2i, @location(11) @interpolate(flat) location_11: vec4u, @location(3) location_3: vec2h) -> VertexOutput4 {
  var out: VertexOutput4;
  out.position = vec4f(bitcast<f32>(location_14));
  out.position = vec4f(out.location_1.yxyx);
  let vf61: bool = override30;
  let ptr28: ptr<private, vec2i> = &vp16;
  vp16 |= bitcast<vec2i>(out.location_9);
  out.position -= bitcast<vec4f>(a7.location_0.abbr.zyzw);
  return out;
  _ = override30;
}

/* used global variables: st25 */
@fragment
fn fragment6(a0: FragmentInput13, a1: FragmentInput14) -> FragmentOutput6 {
  var out: FragmentOutput6;
  textureStore(st25, vec2i(unconst_i32(141204170), unconst_i32(426688024)), vec4u(vec4u(unconst_u32(409590498), unconst_u32(546535708), unconst_u32(890935683), unconst_u32(1803490184))));
  let vf62: u32 = pack4xU8Clamp(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false), unconst_bool(false)) & vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(true)))));
  let vf63: bool = override30;
  var vf64: bool = override30;
  vp16 *= vec2i(out.location_7);
  return out;
  _ = override30;
  _ = st25;
}

/* used global variables: buffer151, buffer152, st23 */
@compute @workgroup_size(1, 2, 1)
fn compute6(a0: ComputeInput7, a1: ComputeInput8, @builtin(global_invocation_id) global_invocation_id: vec3u, a3: ComputeInput9) {
  textureStore(st23, vec2i(unconst_i32(43648101), unconst_i32(428112927)), vec4u(vec4u(unconst_u32(345994391), unconst_u32(594193358), unconst_u32(1806355178), unconst_u32(355142519))));
  let ptr29: ptr<storage, f16, read> = &(*&buffer151)[arrayLength(&(*&buffer151))][unconst_u32(309328780)][3][unconst_u32(637072816)];
  let ptr30: ptr<storage, f16, read_write> = &(*&buffer152)[unconst_u32(270980009)][unconst_u32(1865019839)];
  textureStore(st23, vec2i(unconst_i32(470453962), unconst_i32(79313328)), vec4u(vec4u(unconst_u32(190371036), unconst_u32(200652905), unconst_u32(2060759931), unconst_u32(1176024669))));
  _ = buffer152;
  _ = st23;
  _ = buffer151;
}`,
});
let textureView211 = texture132.createView({dimension: '2d-array', aspect: 'all'});
try {
computePassEncoder44.setBindGroup(3, bindGroup61);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer86, 'uint16', 0, 32);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer106, 0, 1);
} catch {}
try {
renderBundleEncoder17.draw(348, 1, 149_174_188, 1);
} catch {}
try {
buffer28.unmap();
} catch {}
try {
commandEncoder135.copyTextureToTexture({
  texture: texture139,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture71,
  mipLevel: 0,
  origin: {x: 55, y: 0, z: 0},
  aspect: 'all',
},
{width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline37 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 32,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 4, shaderLocation: 4},
          {format: 'uint32x3', offset: 0, shaderLocation: 7},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'uint16x2', offset: 8, shaderLocation: 0},
          {format: 'float32', offset: 0, shaderLocation: 8},
          {format: 'snorm16x4', offset: 0, shaderLocation: 5},
          {format: 'uint32x4', offset: 0, shaderLocation: 13},
          {format: 'float16x2', offset: 4, shaderLocation: 3},
          {format: 'sint32x3', offset: 0, shaderLocation: 1},
          {format: 'float16x4', offset: 0, shaderLocation: 12},
          {format: 'uint32x3', offset: 4, shaderLocation: 15},
          {format: 'sint32x3', offset: 0, shaderLocation: 9},
          {format: 'float16x4', offset: 4, shaderLocation: 6},
          {format: 'uint8x4', offset: 0, shaderLocation: 14},
          {format: 'uint8x4', offset: 0, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [{format: 'unorm10-10-10-2', offset: 0, shaderLocation: 2}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let bindGroup121 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 2, resource: textureView204}, {binding: 11, resource: textureView207}],
});
let textureView212 = texture227.createView({aspect: 'all', baseArrayLayer: 5, arrayLayerCount: 18});
try {
renderPassEncoder37.setIndexBuffer(buffer135, 'uint16', 14, 16);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer132, 'uint16', 36, 0);
} catch {}
try {
commandEncoder196.copyTextureToTexture({
  texture: texture228,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 15},
  aspect: 'all',
},
{
  texture: texture224,
  mipLevel: 0,
  origin: {x: 302, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder40.popDebugGroup();
} catch {}
document.body.append(img4);
let imageData30 = new ImageData(20, 124);
try {
renderPassEncoder26.draw(12, 1, 893_044_063);
} catch {}
try {
renderPassEncoder26.drawIndexed(5, 1, 5, 18_625_582);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer120, 812);
} catch {}
try {
renderBundleEncoder17.drawIndexed(4, 1, 0, 314_492_409, 0);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer110, 32);
} catch {}
try {
  await shaderModule2.getCompilationInfo();
} catch {}
let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte240m', transfer: 'linear'} });
let querySet3 = device1.createQuerySet({type: 'timestamp', count: 586});
let textureView213 = texture215.createView({dimension: 'cube-array', baseArrayLayer: 3, arrayLayerCount: 12});
try {
renderPassEncoder37.setBindGroup(0, bindGroup109);
} catch {}
try {
renderBundleEncoder43.setBindGroup(0, bindGroup109);
} catch {}
try {
commandEncoder196.clearBuffer(buffer134);
} catch {}
try {
device1.queue.writeBuffer(buffer133, 12, new Uint32Array(2535).map((_, i) => i * 4), 1273, 0);
} catch {}
let pipeline38 = await device1.createRenderPipelineAsync({
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule8,
  targets: [{format: 'rg16float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule8,
    buffers: [
      {arrayStride: 8, stepMode: 'instance', attributes: [{format: 'sint8x2', offset: 0, shaderLocation: 9}]},
    ],
  },
});
let shaderModule10 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

diagnostic(info, xyz);

enable f16;

override override33: bool;

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

struct T5 {
  @size(12) f0: atomic<i32>,
}

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

/* zero global variables used */
fn fn1(a0: ptr<function, T4>) -> VertexInput23 {
  var out: VertexInput23;
  var vf69: bool = override31;
  {
  out.location_8 ^= vec2u(u32(override31));
  let vf70: f16 = override32;
  var vf71: f16 = override35;
  _ = override35;
  _ = override31;
  _ = override32;
}
  let ptr31: ptr<function, vec2u> = &out.location_8;
  if bool((*a0).f0.g) {
  var vf72: vec4h = (vec4h(unconst_f16(12592.7), unconst_f16(26698.0), unconst_f16(10887.8), unconst_f16(11806.0)) / unconst_f16(8015.1));
  let vf73: vec4h = radians(vec4h(unconst_f16(4421.3), unconst_f16(16555.2), unconst_f16(7184.1), unconst_f16(2513.3)));
  (*a0).f0 ^= vec2u(pack2x16snorm(vec2f(unconst_f32(0.2291), unconst_f32(0.1208))));
  while bool(atan(vec4h((vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true)) != vec3<bool>((unconst_i32(151712147) < bitcast<i32>(ldexp(vec2h(unconst_f16(866.5), unconst_f16(1401.6)), vec2i(unconst_i32(451621924), unconst_i32(461136750))))))).xxxx))[1]) {
  var vf74: vec3u = reverseBits(vec3u(unconst_u32(1263526273), unconst_u32(203227393), unconst_u32(1473684328)));
  vf74 = vec3u(u32(override32));
  let vf75: vec2f = quantizeToF16(vec2f(unconst_f32(0.1341e24), unconst_f32(0.09959e9)));
  switch vec2i(out.location_8)[1] { 
  default {
  let ptr32: ptr<function, vec2u> = &out.location_8;
  out.location_8 *= vec2u(pack4xU8Clamp(vec4u(unconst_u32(153080023), unconst_u32(334672122), unconst_u32(49453073), unconst_u32(938088040))));
  out.location_8 = (*ptr32);
  return out;
}
  }
  _ = override32;
}
  (*a0).f0 = vec2u(ldexp(vec2h(unconst_f16(-14308.2), unconst_f16(1057.9)), vec2i(unconst_i32(118679997), unconst_i32(466270001))).rr.gr.gg);
  out.location_8 = vec2u(unpack2x16unorm(unconst_u32(84581288)));
  _ = override32;
}
  if bool(override32) {
  (*a0).f0 += vec2u(smoothstep(vec3h(unconst_f16(16939.8), unconst_f16(6386.4), unconst_f16(21161.1)), vec3h(unconst_f16(241.7), unconst_f16(-18924.3), unconst_f16(10658.4)), vec3h(unconst_f16(5697.5), unconst_f16(9256.5), unconst_f16(12845.6))).xx.rg.xx.gr);
  switch i32(select(vec2h( !vec2<bool>(unconst_bool(false), unconst_bool(false)))[0], unconst_f16(27320.9), unconst_bool(true))) { 
  default: {
  let ptr33: ptr<function, vec2u> = &(*a0).f0;
  let ptr34: ptr<function, T4> = &(*a0);
  out.location_8 = vec2u(u32(override35));
  return out;
  _ = override35;
}
case 2400471 {
  var vf76: vec2f = unpack2x16snorm(unconst_u32(163976899));
}
  }
  (*a0).f0 += vec2u(u32(acosh(unconst_f16(10234.7))));
  let vf77: f16 = override35;
  _ = override35;
}
  (*a0).f0 <<= vec2u(override34);
  return out;
  _ = override34;
  _ = override32;
  _ = override35;
  _ = override31;
}

/* zero global variables used */
@must_use 
fn fn0(a0: ptr<storage, f16, read>) -> VertexInput20 {
  var out: VertexInput20;
  var vf65: f16 = override35;
  let vf66: mat3x3h = (mat3x3h(unconst_f16(5393.0), unconst_f16(15421.0), unconst_f16(9879.2), unconst_f16(15423.2), unconst_f16(35093.6), unconst_f16(24863.2), unconst_f16(7495.7), unconst_f16(1481.1), unconst_f16(22488.5)) * mat3x3h(unconst_f16(32523.1), unconst_f16(189.3), unconst_f16(14638.0), unconst_f16(8152.7), unconst_f16(2588.4), unconst_f16(3832.0), unconst_f16(239.1), unconst_f16(17282.6), unconst_f16(13059.2)));
  vf65 -= f16(out.location_11);
  let vf67: vec4f = floor(vec4f(unconst_f32(-0.09121), unconst_f32(0.03733), unconst_f32(0.00805), unconst_f32(0.1206)));
  var vf68: u32 = pack4xI8Clamp(vec4i(unconst_i32(279373522), unconst_i32(11164103), unconst_i32(1107715454), unconst_i32(398189608)));
  vf68 <<= u32(vf65);
  return out;
  _ = override35;
}

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

@group(1) @binding(2) var<storage, read_write> buffer156: array<T5>;

@group(1) @binding(3) var<storage, read> buffer157: array<array<array<array<f16, 1>, 14>, 2>>;

struct VertexInput20 {
  @location(11) location_11: i32,
}

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

/* zero global variables used */
fn fn2() -> VertexInput23 {
  var out: VertexInput23;
  let vf78: vec4h = mix(vec4h(unconst_f16(-24997.2), unconst_f16(1739.0), unconst_f16(6466.1), unconst_f16(2490.8)), vec4h(unconst_f16(7138.6), unconst_f16(32220.7), unconst_f16(14309.8), unconst_f16(15560.6)), vec4h(log(vec4f(unconst_f32(0.1090e-43), unconst_f32(0.2954e-39), unconst_f32(0.01030e-39), unconst_f32(0.05309e-38)))));
  out.location_8 <<= vec2u(u32((f32(length(unconst_f16(25386.9))) >= f32(override35))));
  let vf79: vec2u = extractBits(vec2u(unconst_u32(2743622701), unconst_u32(1006605548)), unconst_u32(426681442), unconst_u32(2138108386));
  var vf80: u32 = (unconst_u32(253004185) << unconst_u32(2996876304));
  return out;
  _ = override35;
}

@group(1) @binding(90) var st29: texture_storage_2d<rgba16uint, write>;

struct VertexInput22 {
  @location(3) location_3: vec4i,
}

@group(0) @binding(90) var st27: texture_storage_2d<rgba16uint, write>;

/* used global variables: buffer154, buffer155, buffer156, buffer157, st27, st29 */
fn fn3() -> T2 {
  var out: T2;
  for (var it2=u32(vw11.f0); it2<(u32(buffer157[arrayLength(&buffer157)][unconst_u32(1220771225)][u32((*&buffer155)[unconst_u32(267201475)][unconst_u32(493347335)][0][unconst_u32(1706031591)][0])][0]) & 0xfff); it2++) {
  out.f0[unconst_u32(92879295)] ^= vec4i(atomicLoad(&buffer156[unconst_i32(85844931)].f0));
  _ = fn0(&buffer155[3][6][unconst_u32(1726489767)][0][0]);
  return out;
  _ = override35;
  _ = buffer155;
  _ = buffer156;
}
  out.f0[unconst_u32(1462242801)] ^= vec4i(i32(buffer155[unconst_u32(214141189)][6][0][0][0]));
  textureStore(st29, vec2i(atomicLoad(&(*&buffer154).f0[0][2])), vec4u(vec4u(unconst_u32(93463795), unconst_u32(316190624), unconst_u32(1685383811), unconst_u32(125053796))));
  for (var jj90=0u; jj90<3; jj90++) { out.f0[jj90] = vec4i(i32((*&buffer157)[unconst_u32(79251007)][1][unconst_u32(85986072)][0])); }
  _ = fn0(&buffer155[3][unconst_u32(2852498376)][0][0][0]);
  switch u32(buffer155[3][6][0][unconst_u32(700707137)][0]) { 
  case default: {
  textureStore(st29, vec2i(unconst_i32(47045579), unconst_i32(101872473)), vec4u(vec4u(unconst_u32(2341641395), unconst_u32(1197784585), unconst_u32(2258497351), unconst_u32(47198869))));
  atomicCompareExchangeWeak(&buffer154.f0[unconst_u32(1626522762)][unconst_u32(937813114)], unconst_i32(-438344605), unconst_i32(20785178));
  let ptr35: ptr<storage, f16, read> = &buffer157[arrayLength(&buffer157)][1][unconst_u32(973996648)][unconst_u32(1274595036)];
  vw11.f0 = bool((*&buffer157)[unconst_u32(105131493)][1][13][u32(buffer155[unconst_u32(323286502)][6][0][0][0])]);
  var vf81: i32 = atomicExchange(&buffer154.f0[unconst_u32(411223035)][2], unconst_i32(839920741));
  _ = buffer155;
  _ = buffer154;
  _ = st29;
  _ = buffer157;
}
  }
  atomicMin(&buffer154.f0[unconst_u32(2204397207)][unconst_u32(81340478)], unconst_i32(240289110));
  let ptr36: ptr<storage, f16, read> = &(*&buffer155)[3][6][unconst_u32(446936057)][0][0];
  textureStore(st27, vec2i(unconst_i32(-732517294), unconst_i32(88098638)), vec4u(vec4u(unconst_u32(1463363366), unconst_u32(164212096), unconst_u32(899154179), unconst_u32(76988611))));
  atomicCompareExchangeWeak(&buffer154.f0[unconst_u32(818182402)][unconst_u32(1333063789)], unconst_i32(187827995), unconst_i32(159518649));
  return out;
  _ = override35;
  _ = buffer156;
  _ = buffer155;
  _ = buffer154;
  _ = st29;
  _ = buffer157;
  _ = st27;
}

struct T4 {
  f0: vec2u,
}

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

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

struct T0 {
  f0: array<u32>,
}

struct T3 {
  @align(2) @size(24) f0: bool,
}

var<workgroup> vw11: T3;

override override35: f16;

@group(0) @binding(2) var<storage, read_write> buffer154: T6;

struct T7 {
  @size(3360) f0: array<T2, 5>,
}

struct VertexOutput5 {
  @location(9) location_9: f32,
  @location(12) location_12: u32,
  @builtin(position) position: vec4f,
  @location(0) location_0: i32,
  @location(4) @interpolate(flat, centroid) location_4: vec2i,
  @location(15) location_15: vec4i,
  @location(2) location_2: vec2h,
  @location(1) location_1: vec4i,
  @location(10) @interpolate(flat) location_10: vec4u,
  @location(8) location_8: vec2h,
  @location(3) location_3: vec4u,
  @location(14) @interpolate(flat, sample) location_14: u32,
  @location(13) location_13: i32,
  @location(5) location_5: vec4i,
  @location(11) @interpolate(flat, center) location_11: f32,
  @location(7) location_7: f16,
  @location(6) location_6: vec4f,
}

struct T1 {
  f0: T0,
}

struct VertexInput23 {
  @location(8) location_8: vec2u,
}

override override32: f16 = 1794.6;

struct T2 {
  @size(56) f0: array<vec4i, 1>,
}

struct VertexInput21 {
  @location(1) @interpolate(flat, sample) location_1: u32,
}

@id(52135) override override36: f16 = 28313.0;

@group(0) @binding(3) var<storage, read> buffer155: array<array<array<array<array<f16, 1>, 1>, 1>, 7>, 4>;

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

alias vec3b = vec3<bool>;

override override34: u32;

@id(1044) override override31 = false;

/* zero global variables used */
@vertex
fn vertex6(@location(15) location_15: vec4u, @builtin(vertex_index) vertex_index: u32, @location(5) @interpolate(flat) location_5: vec2i, a3: VertexInput20, a4: VertexInput21, a5: VertexInput22, @location(14) location_14: vec2u, a7: VertexInput23) -> VertexOutput5 {
  var out: VertexOutput5;
  out.location_3 = (vec2u(unconst_u32(170283643), unconst_u32(815195529)) + vec2u(unconst_u32(208881432), unconst_u32(555698000))).xyyx;
  out.location_5 &= vec4i(out.location_2.xyyx);
  return out;
}

/* used global variables: buffer154, buffer155, buffer156, buffer157, st27, st29 */
@compute @workgroup_size(3, 1, 1)
fn compute7(a0: ComputeInput10) {
  _ = fn0(&(*&buffer157)[arrayLength(&(*&buffer157))][1][13][unconst_u32(65966884)]);
  var vf82 = fn0(&(*&buffer155)[3][bitcast<u32>(atomicLoad(&(*&buffer154).f0[unconst_u32(245145571)][2]))][unconst_u32(2663535166)][0][unconst_u32(357249020)]);
  let ptr37: ptr<storage, atomic<i32>, read_write> = &buffer154.f0[unconst_u32(188305228)][2];
  atomicMin(&buffer156[unconst_u32(693106212)].f0, unconst_i32(1506498047));
  atomicMax(&buffer156[unconst_u32(2155940853)].f0, unconst_i32(152424136));
  loop {
  let ptr38: ptr<storage, f16, read> = &(*&buffer155)[unconst_u32(558721825)][6][0][0][u32((*&buffer157)[arrayLength(&(*&buffer157))][1][unconst_u32(792242258)][0])];
  continuing
  {
  textureStore(st29, vec2i(unconst_i32(705228259), unconst_i32(125217187)), vec4u(vec4u(unconst_u32(2295763965), unconst_u32(779060153), unconst_u32(191984134), unconst_u32(502717370))));
  let ptr39: ptr<storage, f16, read> = &(*&buffer155)[3][unconst_u32(365476788)][0][0][unconst_u32(155138154)];
  for (var it3=u32((*&buffer155)[unconst_u32(1848249891)][6][unconst_u32(694611621)][0][unconst_u32(600935034)]); it3<(u32(buffer155[3][unconst_u32(812121755)][unconst_u32(911867648)][unconst_u32(358347148)][unconst_u32(1523544614)]) & 0xfff); it3++) {
  fn3();
  atomicCompareExchangeWeak(&buffer156[unconst_u32(491743688)].f0, unconst_i32(137446437), unconst_i32(555411449));
  atomicAdd(&buffer156[unconst_u32(66770882)].f0, unconst_i32(172756065));
  break;
  _ = override35;
  _ = st27;
  _ = buffer155;
  _ = buffer154;
  _ = buffer156;
  _ = buffer157;
  _ = st29;
}
  _ = override35;
  _ = buffer155;
  _ = buffer157;
  _ = st27;
  _ = st29;
  _ = buffer156;
  _ = buffer154;
}
  break;
  _ = override35;
  _ = st27;
  _ = buffer156;
  _ = buffer157;
  _ = buffer155;
  _ = buffer154;
  _ = st29;
}
  loop {
  let ptr40: ptr<storage, array<f16, 1>, read> = &(*&buffer157)[unconst_u32(544166425)][unconst_u32(1833506557)][unconst_u32(1424990393)];
  textureStore(st29, vec2i(unconst_i32(409227945), unconst_i32(11526588)), vec4u(vec4u(u32(atomicLoad(&buffer154.f0[0][u32((*&buffer157)[unconst_u32(512551375)][1][unconst_u32(206604318)][0])])))));
  textureStore(st27, vec2i(unconst_i32(16602641), unconst_i32(212802753)), vec4u(unpack4xU8(u32((*&buffer157)[unconst_u32(125971274)][unconst_u32(154840732)][unconst_u32(336957393)][0]))));
  vw11.f0 = bool((*&buffer155)[unconst_u32(498354910)][6][unconst_u32(105923592)][0][0]);
  break;
  _ = st29;
  _ = st27;
  _ = buffer157;
  _ = buffer154;
  _ = buffer155;
}
  let ptr41: ptr<storage, f16, read> = &(*&buffer157)[arrayLength(&(*&buffer157))][unconst_u32(183521765)][unconst_u32(429976322)][unconst_u32(563435794)];
  var vf83 = fn0(&buffer155[bitcast<u32>(atomicLoad(&(*&buffer154).f0[0][2]))][unconst_u32(931781671)][0][unconst_u32(4116429083)][unconst_u32(207296835)]);
  while bool((*&buffer155)[unconst_u32(464163624)][6][unconst_u32(346972181)][0][0]) {
  vw11.f0 = bool(pack4x8snorm(vec4f(unconst_f32(0.02378), unconst_f32(0.02672e38), unconst_f32(0.05079), unconst_f32(0.1059))));
  let ptr42: ptr<storage, array<f16, 1>, read> = &buffer155[3][6][unconst_u32(279249712)][0];
  textureStore(st29, vec2i(unconst_i32(1252880442), unconst_i32(-230908396)), vec4u(vec4u(unconst_u32(551732615), unconst_u32(1925570215), unconst_u32(165150401), unconst_u32(1140642079))));
  storageBarrier();
  break;
  _ = st29;
  _ = buffer155;
}
  vf82.location_11 &= i32((*&buffer157)[arrayLength(&(*&buffer157))][unconst_u32(505648565)][unconst_u32(1929057161)][0]);
  let ptr43: ptr<storage, array<f16, 1>, read> = &buffer155[3][6][0][unconst_u32(399842795)];
  _ = override35;
  _ = buffer156;
  _ = st27;
  _ = buffer154;
  _ = buffer155;
  _ = st29;
  _ = buffer157;
}`,
});
let buffer158 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView214 = texture29.createView({dimension: '2d-array', format: 'eac-r11snorm', mipLevelCount: 1});
try {
computePassEncoder40.setBindGroup(0, bindGroup84, new Uint32Array(1139), 99, 0);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer87, 8);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer138, 28);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
querySet0.destroy();
} catch {}
try {
commandEncoder165.resolveQuerySet(querySet2, 3, 0, buffer137, 0);
} catch {}
let bindGroup122 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [
    {binding: 187, resource: sampler1},
    {binding: 84, resource: {buffer: buffer97, size: 960}},
    {binding: 0, resource: textureView32},
    {binding: 5, resource: textureView148},
    {binding: 181, resource: textureView67},
    {binding: 38, resource: textureView108},
    {binding: 202, resource: {buffer: buffer120}},
    {binding: 1, resource: {buffer: buffer117}},
    {binding: 159, resource: {buffer: buffer62, size: 44}},
    {binding: 93, resource: {buffer: buffer120}},
    {binding: 18, resource: {buffer: buffer124, size: 164}},
    {binding: 244, resource: {buffer: buffer109}},
    {binding: 3, resource: {buffer: buffer76}},
    {binding: 7, resource: sampler28},
  ],
});
try {
computePassEncoder38.setBindGroup(1, bindGroup94, [0, 0]);
} catch {}
try {
renderPassEncoder28.setBindGroup(1, bindGroup93, new Uint32Array(140), 9, 0);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 66, 0, 115_086_546, 326_837_507);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer72, 88);
} catch {}
try {
renderBundleEncoder17.drawIndexedIndirect(buffer136, 0);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer62, 60);
} catch {}
let shaderModule11 = device1.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires packed_4x8_integer_dot_product;

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

struct VertexInput25 {
  @location(9) @interpolate(flat, either) location_9: i32,
}

struct FragmentInput16 {
  @location(8) @interpolate(linear, first) location_8: vec2h,
}

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

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

struct T1 {
  @align(8) f0: array<u32>,
}

struct FragmentInput17 {
  @location(6) @interpolate(linear, centroid) location_6: vec4f,
}

struct T4 {
  @size(256) f0: array<vec2<bool>, 1>,
}

struct VertexOutput6 {
  @location(5) @interpolate(flat, centroid) location_5: vec4i,
  @builtin(position) position: vec4f,
  @location(6) @interpolate(linear, centroid) location_6: vec4f,
  @location(15) location_15: vec2u,
  @location(11) location_11: f32,
  @location(3) @interpolate(perspective, centroid) location_3: vec4f,
  @location(7) @interpolate(flat, sample) location_7: f16,
  @location(12) location_12: i32,
  @location(8) @interpolate(linear, first) location_8: vec2h,
  @location(2) location_2: f32,
  @location(1) @interpolate(flat) location_1: vec2u,
  @location(14) @interpolate(flat, first) location_14: vec2u,
  @location(0) @interpolate(flat, centroid) location_0: vec4i,
  @location(4) location_4: vec2i,
}

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

struct T3 {
  @align(16) @size(16) f0: array<array<array<array<vec2h, 1>, 2>, 1>, 1>,
  f1: T0,
}

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

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

struct FragmentInput15 {
  @location(15) location_15: vec2u,
  @location(14) @interpolate(flat, first) location_14: vec2u,
  @location(0) @interpolate(flat, centroid) location_0: vec4i,
  @location(2) location_2: f32,
  @location(5) @interpolate(flat, centroid) location_5: vec4i,
}

struct T5 {
  f0: vec4h,
}

struct VertexInput24 {
  @location(8) @interpolate(flat, first) location_8: i32,
  @location(10) @interpolate(perspective) location_10: f16,
  @location(7) location_7: f32,
  @location(11) location_11: vec2i,
  @builtin(instance_index) instance_index: u32,
  @location(14) location_14: vec2f,
  @builtin(vertex_index) vertex_index: u32,
  @location(13) @interpolate(linear, center) location_13: vec2f,
  @location(5) @interpolate(flat) location_5: vec4i,
  @location(2) location_2: vec4u,
}

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

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

var<private> vp18: FragmentInput16 = FragmentInput16(vec2h(7018.7, 11985.3));

var<workgroup> vw12: FragmentInput18;

struct T2 {
  @align(32) f0: array<vec4<bool>>,
}

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

struct VertexInput26 {
  @location(12) @interpolate(flat) location_12: vec4i,
}

/* zero global variables used */
@vertex
fn vertex7(a0: VertexInput24, @location(3) location_3: vec2u, @location(6) @interpolate(linear) location_6: vec4h, @location(0) location_0: u32, @location(1) location_1: vec2u, a5: VertexInput25, a6: VertexInput26, @location(15) location_15: vec4f) -> VertexOutput6 {
  var out: VertexOutput6;
  let vf84: vec4i = a0.location_5;
  out.location_0 -= bitcast<vec4i>(out.location_3.zywx);
  var vf85: f32 = a0.location_14[unconst_u32(944463547)];
  vp18.location_8 -= vec2h(out.location_6.ba.rg);
  out.location_8 += vp18.location_8;
  let ptr44: ptr<private, vec2h> = &vp18.location_8;
  out.position = vec4f(bitcast<f32>(a0.location_5[unconst_u32(560121884)]));
  var vf86: vec4i = a0.location_5;
  let vf87: vec2i = (vec2i(unconst_i32(246551969), unconst_i32(273205698)) << vec2u(unconst_u32(2051678306), unconst_u32(295870579)));
  var vf88: u32 = a0.vertex_index;
  return out;
}

/* zero global variables used */
@fragment
fn fragment7(a0: FragmentInput15, @location(4) location_4: vec2i, @location(7) @interpolate(flat) location_7: f16, @location(12) location_12: i32, @location(1) location_1: vec2u, a5: FragmentInput16, a6: FragmentInput17, @location(3) @interpolate(perspective) location_3: vec4f, @location(11) @interpolate(flat) location_11: f32, a9: FragmentInput18, a10: FragmentInput19) -> FragmentOutput7 {
  var out: FragmentOutput7;
  vp18.location_8 += bitcast<vec2h>(a10.sample_index);
  var vf89: vec2<bool> = (vec2h(unconst_f16(3049.8), unconst_f16(2159.5)) > vec2h(unconst_f16(14302.6), unconst_f16(17587.1)));
  var vf90: i32 = location_4[unconst_u32(398609418)];
  let vf91: vec4i = unpack4xI8(unconst_u32(57641767));
  var vf92: bool = vf89[unconst_u32(495112353)];
  vf89 = vec2<bool>((vec3f(unconst_f32(0.1272e31), unconst_f32(0.00226e11), unconst_f32(-0.2839)) * mat3x3f(unconst_f32(0.4812e34), unconst_f32(0.2904), unconst_f32(0.2305e9), unconst_f32(0.1049e-2), unconst_f32(0.3281e37), unconst_f32(0.2358), unconst_f32(0.4541e29), unconst_f32(0.01377e38), unconst_f32(0.1451e-26))).br.rr.gr.xx);
  let ptr45: ptr<private, vec2h> = &vp18.location_8;
  vp18.location_8 = smoothstep(vec3h(unconst_f16(268.1), unconst_f16(13578.9), unconst_f16(19395.0)), vec3h(unconst_f16(29173.4), unconst_f16(3601.1), unconst_f16(1447.8)), vec3h(unconst_f16(27277.3), unconst_f16(6579.2), unconst_f16(12224.3))).gr;
  vf92 = bool(location_11);
  vf89 = vec2<bool>(unpack4xI8(unconst_u32(941520072)).xw);
  return out;
}`,
});
let buffer159 = device1.createBuffer({size: 408, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder200 = device1.createCommandEncoder();
let renderBundleEncoder44 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder38.setVertexBuffer(0, buffer145);
} catch {}
try {
renderBundleEncoder41.setBindGroup(1, bindGroup117, new Uint32Array(796), 404, 0);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline38);
} catch {}
let pipeline39 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, entryPoint: 'compute5', constants: {}}});
let veryExplicitBindGroupLayout21 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 12,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 27,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 59, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
  ],
});
let buffer160 = device1.createBuffer({
  size: 112,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let renderBundleEncoder45 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], stencilReadOnly: true});
try {
computePassEncoder41.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline38);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(5, buffer145, 0, 58);
} catch {}
try {
buffer133.unmap();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 150, height: 21, depthOrArrayLayers: 1}
*/
{
  source: imageData13,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture218,
  mipLevel: 2,
  origin: {x: 33, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline40 = device1.createRenderPipeline({
  layout: pipelineLayout4,
  multisample: {mask: 0xffffffff},
  fragment: {
  module: shaderModule8,
  targets: [{format: 'rg16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule8,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'sint16x2', offset: 88, shaderLocation: 9}],
      },
    ],
  },
});
let buffer161 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let renderBundleEncoder46 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
renderPassEncoder26.setBindGroup(2, bindGroup116, new Uint32Array(453), 40, 1);
} catch {}
try {
renderPassEncoder11.draw(0, 67, 0, 27_689_108);
} catch {}
try {
renderPassEncoder26.drawIndexed(2, 1, 0, 95_341_985);
} catch {}
let promise24 = device0.queue.onSubmittedWorkDone();
let bindGroup123 = device0.createBindGroup({layout: autogeneratedBindGroupLayout9, entries: [{binding: 2, resource: {buffer: buffer38}}]});
let buffer162 = device0.createBuffer({size: 592, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let textureView215 = texture99.createView({baseMipLevel: 0});
try {
computePassEncoder27.setBindGroup(1, bindGroup74, new Uint32Array(608), 19, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup96, new Uint32Array(1211), 144, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer61, 80);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup32);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup107, new Uint32Array(4), 0, 0);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer71, 'uint32', 4, 20);
} catch {}
let bindGroup124 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 11, resource: textureView207}, {binding: 2, resource: textureView204}],
});
let commandEncoder201 = device1.createCommandEncoder({});
let texture232 = device1.createTexture({
  size: {width: 12, height: 120, depthOrArrayLayers: 66},
  mipLevelCount: 1,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC,
});
let computePassEncoder52 = commandEncoder201.beginComputePass();
try {
renderPassEncoder35.setIndexBuffer(buffer135, 'uint32', 8, 1);
} catch {}
try {
buffer139.unmap();
} catch {}
let buffer163 = device0.createBuffer({size: 212, usage: GPUBufferUsage.INDEX});
let commandEncoder202 = device0.createCommandEncoder({});
try {
computePassEncoder21.setBindGroup(1, bindGroup44);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer21, 12);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer77, 228);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer18, 'uint16', 10, 12);
} catch {}
try {
renderBundleEncoder17.draw(219, 1, 46_233_082, 1);
} catch {}
try {
renderBundleEncoder17.drawIndexed(3, 2, 1, 26_574_225);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer128, 36);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 0, new DataView(new ArrayBuffer(79536)), 2124, 0);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
try {
  await promise24;
} catch {}
let shaderModule12 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

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

@group(1) @binding(1) var et17: texture_external;

struct VertexInput28 {
  @builtin(instance_index) instance_index: u32,
  @location(4) @interpolate(perspective) location_4: f32,
}

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

@id(18684) override override37: u32;

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

struct VertexInput32 {
  @location(9) @interpolate(linear) location_9: f16,
}

alias vec3b = vec3<bool>;

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

@group(1) @binding(0) var st32: texture_storage_3d<r32float, read_write>;

@group(0) @binding(2) var<storage, read_write> buffer164: array<array<array<array<array<array<array<array<array<array<VertexInput32, 1>, 3>, 1>, 1>, 1>, 1>, 1>, 2>, 1>>;

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

struct FragmentInput20 {
  @location(13) location_13: f32,
  @location(10) location_10: u32,
  @builtin(front_facing) front_facing: bool,
}

/* zero global variables used */
fn fn0(a0: texture_external, a1: texture_external) {
  let vf93: vec2<bool> = (vec2f(unconst_f32(0.04323e34), unconst_f32(-0.6026e5)) != vec2f(unconst_f32(0.2678), unconst_f32(0.09327)));
  _ = a1;
  let vf94: f32 = override38;
  _ = a0;
  _ = override38;
}

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

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

struct VertexOutput7 {
  @location(13) location_13: f32,
  @location(10) location_10: u32,
  @builtin(position) position: vec4f,
}

@id(39103) override override39 = false;

override override43 = 0.01846e-8;

struct VertexInput29 {
  @location(0) location_0: vec2h,
  @location(3) location_3: vec2f,
}

@group(0) @binding(0) var st30: texture_storage_3d<r32float, read_write>;

struct FragmentOutput8 {
  @builtin(sample_mask) sample_mask: u32,
  @location(1) location_1: vec4f,
  @location(0) @interpolate(perspective, first) location_0: vec4f,
}

struct VertexInput33 {
  @location(11) @interpolate(perspective, either) location_11: f32,
  @location(10) location_10: vec4f,
}

@id(16733) override override41: u32;

override override40 = 0.03667e13;

override override42: i32 = 58905767;

struct VertexInput27 {
  @location(7) location_7: f32,
  @location(13) location_13: vec4f,
}

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

@id(37824) override override38: f32;

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

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

override override44: f32;

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

/* used global variables: et17 */
@vertex
fn vertex8(@location(2) @interpolate(flat) location_2: i32, @location(11) @interpolate(flat) location_11: vec2f, a2: VertexInput27, @location(1) location_1: vec2f, @location(15) @interpolate(flat, centroid) location_15: vec4i, @location(6) @interpolate(flat, sample) location_6: vec2i, a6: VertexInput28, a7: VertexInput29, @location(14) location_14: f32, a9: VertexInput30, a10: VertexInput31, a11: VertexInput32) -> @builtin(position) vec4f {
  var out: vec4f;
  var vf95: f32 = location_1[unconst_u32(452189550)];
  var vf96: vec4h = a10.location_8;
  out = location_11.rrrr;
  let vf97: vec2i = location_6;
  fn0(et17, et17);
  vf96 = vec4h(f16(a2.location_7));
  out += vec4f(textureDimensions(et17).rggr);
  return out;
  _ = override38;
  _ = et17;
}

/* zero global variables used */
@vertex
fn vertex9(a0: VertexInput33, @location(1) location_1: vec2i) -> VertexOutput7 {
  var out: VertexOutput7;
  out.position *= vec4f(bitcast<f32>(pack4x8snorm(vec4f(unconst_f32(0.09517e13), unconst_f32(0.1700), unconst_f32(0.2456e-16), unconst_f32(-0.09601)))));
  out.location_10 &= u32(floor(unconst_f16(17408.3)));
  let vf98: u32 = firstLeadingBit(unconst_u32(380556531));
  out.position = vec4f(a0.location_11);
  return out;
}

/* used global variables: st30, st32 */
@fragment
fn fragment8(a0: FragmentInput20, a1: FragmentInput21, a2: FragmentInput22) -> FragmentOutput8 {
  var out: FragmentOutput8;
  let ptr46: ptr<function, vec4f> = &out.location_1;
  let vf99: ptr<function, vec4f> = ptr46;
  let vf100: bool = a0.front_facing;
  var vf101: bool = a0.front_facing;
  var vf102: FragmentInput22 = a2;
  let ptr47: ptr<function, vec4f> = &out.location_1;
  var vf103: vec3u = textureDimensions(st32);
  out.location_1 = textureLoad(st30, vec3i(unconst_i32(780321671), unconst_i32(11789243), unconst_i32(134187138)));
  out.sample_mask &= bitcast<u32>(override40);
  return out;
  _ = override40;
  _ = st32;
  _ = st30;
}

/* used global variables: buffer164 */
@compute @workgroup_size(1, 1, 1)
fn compute8(@builtin(global_invocation_id) global_invocation_id: vec3u, a1: ComputeInput11, @builtin(local_invocation_id) local_invocation_id: vec3u) {
  let ptr48: ptr<storage, VertexInput32, read_write> = &buffer164[unconst_u32(297391711)][0][1][0][unconst_u32(1489180779)][unconst_u32(2160891812)][0][unconst_u32(107343931)][unconst_u32(1154182795)][0];
  _ = buffer164;
}`,
});
try {
computePassEncoder32.setBindGroup(1, bindGroup115);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer77, 60);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer71, 4);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline32);
} catch {}
try {
renderBundleEncoder25.setBindGroup(2, bindGroup32, new Uint32Array(1231), 67, 0);
} catch {}
try {
renderBundleEncoder38.setPipeline(pipeline7);
} catch {}
let recycledExplicitBindGroupLayout10 = pipeline38.getBindGroupLayout(0);
let texture233 = device1.createTexture({
  size: [6, 60, 66],
  mipLevelCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder53 = commandEncoder187.beginComputePass();
try {
renderPassEncoder37.setPipeline(pipeline40);
} catch {}
document.body.prepend(canvas1);
let bindGroup125 = device1.createBindGroup({layout: recycledExplicitBindGroupLayout10, entries: [{binding: 1, resource: textureView167}]});
let textureView216 = texture233.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 3});
let renderBundleEncoder47 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float']});
try {
computePassEncoder50.setBindGroup(0, bindGroup109, new Uint32Array(198), 32, 0);
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup109, new Uint32Array(767), 368, 0);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer135, 'uint16', 14, 15);
} catch {}
try {
renderBundleEncoder44.setPipeline(pipeline40);
} catch {}
let texture234 = device0.createTexture({
  size: {width: 1488},
  dimension: '1d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder9.setPipeline(pipeline29);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let buffer167 = device0.createBuffer({size: 392, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let textureView217 = texture136.createView({});
let renderBundleEncoder48 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: false});
try {
renderPassEncoder26.draw(646, 1, 557_077_772);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, -1_823_275_780);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer67, 0);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer18, 'uint16', 8, 9);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer56, 12);
} catch {}
try {
renderBundleEncoder28.setBindGroup(2, bindGroup41, new Uint32Array(710), 37, 0);
} catch {}
try {
commandEncoder170.resolveQuerySet(querySet0, 248, 1, buffer67, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer97, 8, new Uint16Array(4483).map((_, i) => i + 1), 988, 328);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(92); };
} catch {}
let sampler34 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.87,
  maxAnisotropy: 3,
});
try {
renderPassEncoder32.setBindGroup(2, bindGroup115, new Uint32Array(1234), 280, 0);
} catch {}
try {
renderPassEncoder4.draw(44, 0, 411_648_125);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 309, 0, 651_468_461, 19_510_423);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer39, 64);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(1, buffer22, 0);
} catch {}
try {
renderBundleEncoder25.setBindGroup(0, bindGroup88, new Uint32Array(2565), 297, 1);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer116, 0);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(0, buffer0, 0, 1);
} catch {}
let promise25 = device0.queue.onSubmittedWorkDone();
let pipeline41 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment2',
  constants: {59_276: 1},
  targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex2',
    buffers: [
      {
        arrayStride: 44,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 8, shaderLocation: 0},
          {format: 'snorm8x2', offset: 0, shaderLocation: 2},
          {format: 'unorm8x4', offset: 0, shaderLocation: 5},
          {format: 'snorm16x4', offset: 32, shaderLocation: 8},
          {format: 'uint32x4', offset: 0, shaderLocation: 7},
          {format: 'uint8x4', offset: 4, shaderLocation: 15},
          {format: 'uint32x4', offset: 4, shaderLocation: 11},
          {format: 'snorm16x4', offset: 4, shaderLocation: 12},
          {format: 'sint32x4', offset: 0, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 44,
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 3},
          {format: 'sint16x2', offset: 0, shaderLocation: 1},
          {format: 'float32x4', offset: 16, shaderLocation: 10},
          {format: 'uint32x3', offset: 0, shaderLocation: 14},
          {format: 'float32x4', offset: 0, shaderLocation: 6},
          {format: 'uint8x4', offset: 0, shaderLocation: 13},
          {format: 'uint32x4', offset: 8, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
let adapter3 = await navigator.gpu.requestAdapter({});
try {
renderPassEncoder26.drawIndexed(2, 1, 1, 612_535_421);
} catch {}
try {
device0.queue.writeBuffer(buffer39, 116, new DataView(new ArrayBuffer(676)), 527, 0);
} catch {}
let imageBitmap3 = await createImageBitmap(imageData17);
let buffer168 = device0.createBuffer({size: 144, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let texture235 = device0.createTexture({
  size: {width: 180, height: 105, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler35 = device0.createSampler({addressModeW: 'mirror-repeat', magFilter: 'linear', minFilter: 'linear'});
try {
renderPassEncoder4.draw(46, 0, 46_391_181);
} catch {}
try {
renderPassEncoder26.drawIndexed(4, 1, 1, 780_456_436);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer77, 'uint16', 6, 40);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer22, 16, 8);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(1, buffer86, 0, 32);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await promise25;
} catch {}
let querySet4 = device1.createQuerySet({
  label: '\u3528\u017b\u14c5\u8a39\u813d\u266e\u0e2b\u{1fcca}\u3a35\u71d4',
  type: 'timestamp',
  count: 268,
});
let textureView218 = texture225.createView({dimension: '2d', baseArrayLayer: 7});
let textureView219 = texture198.createView({baseArrayLayer: 1, arrayLayerCount: 6});
try {
computePassEncoder53.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup117);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer135, 'uint32', 12, 6);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(6, buffer135);
} catch {}
let texture236 = device1.createTexture({
  size: [600],
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder34.setBindGroup(0, bindGroup117);
} catch {}
try {
renderBundleEncoder40.setVertexBuffer(1, buffer126, 0, 9);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 150, height: 21, depthOrArrayLayers: 1}
*/
{
  source: videoFrame18,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture218,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup126 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [
    {binding: 3, resource: {buffer: buffer161, size: 56}},
    {binding: 0, resource: textureView1},
    {binding: 90, resource: textureView8},
    {binding: 1, resource: externalTexture0},
    {binding: 2, resource: {buffer: buffer1}},
  ],
});
let textureView220 = texture234.createView({});
let texture237 = device0.createTexture({
  size: {width: 372, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView221 = texture103.createView({arrayLayerCount: 2});
try {
renderPassEncoder28.executeBundles([renderBundle18, renderBundle15, renderBundle3]);
} catch {}
try {
renderPassEncoder4.draw(212, 0, 891_749_093);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer108, 'uint32', 100, 33);
} catch {}
try {
  await shaderModule12.getCompilationInfo();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(87).fill(99), /* required buffer size: 87 */
{offset: 87}, {width: 116, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup127 = device1.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 1, resource: textureView176}]});
let commandEncoder203 = device1.createCommandEncoder({});
let renderPassEncoder39 = commandEncoder199.beginRenderPass({
  colorAttachments: [{
  view: textureView185,
  depthSlice: 83,
  clearValue: { r: -210.1, g: -748.5, b: -262.2, a: 830.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet4},
});
let renderBundleEncoder49 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true, stencilReadOnly: true});
let recycledExplicitBindGroupLayout11 = pipeline38.getBindGroupLayout(0);
let texture238 = device1.createTexture({
  size: {width: 6, height: 60, depthOrArrayLayers: 139},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder40 = commandEncoder195.beginRenderPass({
  colorAttachments: [{
  view: textureView192,
  clearValue: { r: -803.5, g: 625.6, b: 981.2, a: -294.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderBundleEncoder40.setVertexBuffer(3, buffer147);
} catch {}
try {
buffer131.unmap();
} catch {}
let texture239 = device0.createTexture({
  size: [64],
  sampleCount: 1,
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder11.drawIndirect(buffer138, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline37);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline29);
} 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',
});
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let commandEncoder204 = device1.createCommandEncoder({});
let texture240 = device1.createTexture({
  size: [6],
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder54 = commandEncoder203.beginComputePass({timestampWrites: {querySet: querySet4, endOfPassWriteIndex: 12}});
try {
computePassEncoder50.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder39.setBindGroup(3, bindGroup125);
} catch {}
try {
renderBundleEncoder34.setBindGroup(0, bindGroup117, new Uint32Array(78), 0, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer134, 4, new Uint32Array(6844).map((_, i) => i * 2), 1187, 0);
} catch {}
let pipeline42 = device1.createRenderPipeline({
  layout: pipelineLayout4,
  multisample: {mask: 0x4148b8ac},
  fragment: {
  module: shaderModule11,
  constants: {},
  targets: [{format: 'rgba32float', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule11,
    buffers: [
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 24, shaderLocation: 8},
          {format: 'uint8x4', offset: 12, shaderLocation: 1},
          {format: 'snorm16x4', offset: 24, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 7},
          {format: 'uint8x2', offset: 16, shaderLocation: 0},
          {format: 'unorm8x2', offset: 18, shaderLocation: 6},
          {format: 'snorm8x4', offset: 0, shaderLocation: 14},
          {format: 'sint16x4', offset: 40, shaderLocation: 11},
          {format: 'uint32', offset: 0, shaderLocation: 3},
          {format: 'sint32x3', offset: 0, shaderLocation: 9},
          {format: 'uint32x3', offset: 8, shaderLocation: 2},
          {format: 'float32x4', offset: 0, shaderLocation: 13},
          {format: 'sint32', offset: 0, shaderLocation: 5},
          {format: 'sint8x2', offset: 0, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 176, shaderLocation: 15}],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
let commandEncoder205 = device0.createCommandEncoder({});
let commandBuffer30 = commandEncoder30.finish();
let textureView222 = texture223.createView({mipLevelCount: 1});
try {
renderPassEncoder0.setBindGroup(1, bindGroup37, [0]);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 262, 0, 47_467_522, 42_258_045);
} catch {}
try {
renderBundleEncoder35.setBindGroup(1, bindGroup26, new Uint32Array(4348), 134, 0);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer84, 'uint16', 120, 27);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline7);
} catch {}
try {
buffer168.unmap();
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer65, 8, new Uint32Array(21244).map((_, i) => i * 7), 2143, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2345, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 1086, y: 20, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 5, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let veryExplicitBindGroupLayout22 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 31,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {binding: 47, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {binding: 53, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 23, hasDynamicOffset: false },
    },
    {
      binding: 114,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 154, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 202,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 445,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 523,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 775,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let bindGroup128 = device1.createBindGroup({layout: recycledExplicitBindGroupLayout11, entries: [{binding: 1, resource: textureView167}]});
let texture241 = device1.createTexture({size: [6, 60, 2], dimension: '3d', format: 'rg16float', usage: GPUTextureUsage.COPY_SRC});
try {
renderBundleEncoder49.setPipeline(pipeline38);
} catch {}
try {
renderBundleEncoder43.setVertexBuffer(6, buffer145, 96, 6);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 60, depthOrArrayLayers: 66}
*/
{
  source: offscreenCanvas4,
  origin: { x: 7, y: 1 },
  flipY: false,
}, {
  texture: texture194,
  mipLevel: 0,
  origin: {x: 0, y: 5, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let device2 = await adapter3.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'bgra8unorm-storage',
    'timestamp-query',
  ],
  requiredLimits: {
    maxStorageTexturesPerShaderStage: 4,
    maxUniformBufferBindingSize: 30416547,
    maxStorageBufferBindingSize: 163641798,
  },
});
let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 122,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let autogeneratedBindGroupLayout10 = pipeline28.getBindGroupLayout(0);
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 27});
let texture242 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView223 = texture79.createView({});
try {
computePassEncoder44.setBindGroup(2, bindGroup103);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline43 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6}});
document.body.prepend(canvas0);
let texture243 = device1.createTexture({
  size: [12, 120, 66],
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture244 = device1.createTexture({
  size: {width: 600, height: 87, depthOrArrayLayers: 1},
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder50 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthReadOnly: true});
try {
computePassEncoder45.setBindGroup(3, bindGroup125, new Uint32Array(71), 4, 0);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline39);
} catch {}
try {
renderBundleEncoder47.setBindGroup(0, bindGroup117, new Uint32Array(1711), 439, 0);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(0, buffer135, 0, 31);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture224,
  mipLevel: 0,
  origin: {x: 224, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(408).fill(161), /* required buffer size: 408 */
{offset: 408}, {width: 149, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 150, height: 21, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas7,
  origin: { x: 25, y: 48 },
  flipY: true,
}, {
  texture: texture200,
  mipLevel: 0,
  origin: {x: 4, y: 4, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(3); };
} catch {}
let commandEncoder206 = device2.createCommandEncoder({});
let renderBundleEncoder51 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder10.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 63_969_232);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer93, 'uint16', 4, 29);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer105, 12);
} catch {}
try {
commandEncoder89.insertDebugMarker('\u{1f7f8}');
} catch {}
let imageBitmap4 = await createImageBitmap(imageData2);
let textureView224 = texture243.createView({dimension: '2d', baseArrayLayer: 1});
let renderPassEncoder41 = commandEncoder196.beginRenderPass({
  colorAttachments: [{
  view: textureView177,
  clearValue: { r: -17.95, g: -10.66, b: 885.3, a: 790.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 229304925,
});
try {
computePassEncoder52.setBindGroup(2, bindGroup125, new Uint32Array(1048), 60, 0);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let promise27 = device1.queue.onSubmittedWorkDone();
try {
device1.queue.copyExternalImageToTexture(/*
{width: 150, height: 21, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas5,
  origin: { x: 3, y: 25 },
  flipY: false,
}, {
  texture: texture200,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 9, depthOrArrayLayers: 0});
} catch {}
let commandEncoder207 = device2.createCommandEncoder({});
let sampler36 = device2.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 67.90,
  maxAnisotropy: 16,
});
let renderBundleEncoder52 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], stencilReadOnly: true});
try {
renderBundleEncoder52.setVertexBuffer(1, undefined, 221_466_500);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte240m', transfer: 'logSqrt'} });
let texture245 = device2.createTexture({
  size: [337, 82, 158],
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture246 = device2.createTexture({
  size: {width: 1350, height: 330, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView225 = texture245.createView({});
let renderBundleEncoder53 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true});
let veryExplicitBindGroupLayout24 = device2.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 10, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 49,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 26, hasDynamicOffset: false },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 142, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 440,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let commandEncoder208 = device2.createCommandEncoder({});
let texture247 = device2.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 13},
  mipLevelCount: 1,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView226 = texture246.createView({});
let renderBundleEncoder54 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], stencilReadOnly: true});
try {
renderBundleEncoder53.setVertexBuffer(7, undefined);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture246,
  mipLevel: 0,
  origin: {x: 290, y: 46, z: 0},
  aspect: 'all',
}, new Uint8Array(377).fill(33), /* required buffer size: 377 */
{offset: 377, bytesPerRow: 488}, {width: 243, height: 58, depthOrArrayLayers: 0});
} catch {}
let buffer169 = device1.createBuffer({
  label: '\u03d6\uc3ec\u0a5b\u0c02\u0e6f\u01d6\u{1f860}',
  size: 360,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder209 = device1.createCommandEncoder();
try {
computePassEncoder49.setPipeline(pipeline39);
} catch {}
let imageData31 = new ImageData(68, 40);
let texture248 = device0.createTexture({
  size: {width: 360, height: 210, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView227 = texture85.createView({});
try {
renderPassEncoder11.drawIndexed(0, 81, 0, 571_820_803, 939_571_747);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer78, 8);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer109, 'uint32', 32, 4);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer13, 0, 2);
} catch {}
try {
renderBundleEncoder17.drawIndirect(buffer138, 80);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer128, 4, 13);
} catch {}
let veryExplicitBindGroupLayout25 = device2.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 10, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 49,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 26, hasDynamicOffset: false },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 142, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 440,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let textureView228 = texture245.createView({dimension: '3d'});
try {
  await promise27;
} catch {}
let texture249 = device2.createTexture({
  size: {width: 168, height: 41, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'depth32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder42 = commandEncoder207.beginRenderPass({
  colorAttachments: [{
  view: textureView226,
  clearValue: { r: 298.7, g: -171.5, b: -131.5, a: 952.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 265921032,
});
let renderBundleEncoder55 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true});
try {
renderPassEncoder42.setBlendConstant({ r: 759.6, g: -828.9, b: -868.1, a: 773.7, });
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas1);
let textureView229 = texture247.createView({dimension: '2d'});
let querySet6 = device1.createQuerySet({type: 'timestamp', count: 326});
let renderBundleEncoder56 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder43.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder40.setBindGroup(0, bindGroup117, new Uint32Array(92), 14, 0);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer135, 'uint16', 16, 3);
} catch {}
try {
renderPassEncoder41.setVertexBuffer(2, buffer145, 4, 14);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device1.queue.writeBuffer(buffer134, 4, new DataView(new Uint8Array(5167).map((_, i) => i).buffer), 1706, 60);
} catch {}
try {
  await promise26;
} catch {}
let commandEncoder210 = device1.createCommandEncoder({});
try {
computePassEncoder45.setPipeline(pipeline39);
} catch {}
try {
  await buffer159.mapAsync(GPUMapMode.WRITE, 24, 40);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device1.queue.submit([commandBuffer29]);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let bindGroup129 = device0.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 2, resource: {buffer: buffer120}}]});
let commandEncoder211 = device0.createCommandEncoder({});
let renderBundleEncoder57 = device0.createRenderBundleEncoder({colorFormats: ['r16uint'], depthReadOnly: true});
try {
computePassEncoder36.setBindGroup(1, bindGroup102, new Uint32Array(3093), 66, 0);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(272);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer110, 0);
} catch {}
try {
renderBundleEncoder13.draw(0, 123, 0, 3_023_387_445);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.submit([commandBuffer30]);
} catch {}
let buffer170 = device0.createBuffer({size: 125, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let texture250 = device0.createTexture({
  size: [293, 6, 53],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView230 = texture26.createView({dimension: '2d-array'});
let renderBundleEncoder58 = device0.createRenderBundleEncoder({colorFormats: ['rg11b10ufloat'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder4.draw(308, 0, 3_261_592_178);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer18, 20);
} catch {}
try {
renderBundleEncoder51.setBindGroup(1, bindGroup88, new Uint32Array(95), 16, 1);
} catch {}
let textureView231 = texture250.createView({label: '\ua200\ue671\u205f\u5daa\uaa40\ud130\u0f0c\u8cf5\u{1fa8f}\u0813'});
let texture251 = device0.createTexture({
  size: {width: 586},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder44.setBindGroup(1, bindGroup97, new Uint32Array(149), 16, 2);
} catch {}
try {
renderPassEncoder26.draw(81, 1, 2_235_762_518);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 263, 0, -2_125_800_369, 343_821_017);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer87, 28);
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 480 widthInBlocks: 240 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 750 */
  offset: 750,
  bytesPerRow: 7168,
  buffer: buffer68,
}, {
  texture: texture26,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, {width: 240, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2345, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame27,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 411, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView232 = texture202.createView({baseMipLevel: 0});
let textureView233 = texture238.createView({mipLevelCount: 1});
try {
computePassEncoder54.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder37.setBindGroup(1, bindGroup117, new Uint32Array(3392), 653, 0);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(5, buffer135, 0, 1);
} catch {}
try {
texture228.destroy();
} catch {}
let imageData32 = new ImageData(44, 64);
let pipelineLayout8 = device2.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout25, veryExplicitBindGroupLayout25]});
let texture252 = device2.createTexture({
  size: [168, 41, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture253 = device2.createTexture({size: [675, 165, 5], dimension: '3d', format: 'r16float', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder55 = commandEncoder206.beginComputePass();
let renderPassEncoder43 = commandEncoder208.beginRenderPass({
  colorAttachments: [{
  view: textureView226,
  clearValue: { r: -647.9, g: -353.2, b: -244.2, a: -509.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 5324003,
});
let texture254 = device0.createTexture({
  size: {width: 102, height: 1, depthOrArrayLayers: 87},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture255 = device0.createTexture({
  size: {width: 102, height: 1, depthOrArrayLayers: 174},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundle19 = renderBundleEncoder13.finish({});
try {
computePassEncoder29.setBindGroup(0, bindGroup70, new Uint32Array(2118), 5, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup79);
} catch {}
try {
renderPassEncoder31.beginOcclusionQuery(2292);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer148, 64);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer148, 56);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(6, buffer95, 0);
} catch {}
try {
renderBundleEncoder30.setBindGroup(0, bindGroup119);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer109, 'uint32', 20, 24);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(0, buffer118, 32);
} catch {}
let bindGroup130 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 90, resource: textureView57},
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer34, size: 40}},
    {binding: 3, resource: {buffer: buffer34}},
    {binding: 1, resource: externalTexture8},
  ],
});
let commandEncoder212 = device0.createCommandEncoder({});
let textureView234 = texture254.createView({dimension: '2d', baseArrayLayer: 31});
let texture256 = device0.createTexture({
  size: [372, 1, 54],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder31.endOcclusionQuery();
} catch {}
try {
renderPassEncoder26.drawIndexed(3, 1, 3, 165_464_072, 0);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer87, 8);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer97, 240, 54);
} catch {}
try {
renderBundleEncoder28.drawIndexed(1, 1, 0, -1_882_307_875);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let texture257 = device0.createTexture({
  size: {width: 816},
  dimension: '1d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder26.draw(43, 1, 756_566_898, 0);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 537_534_914, 0);
} catch {}
try {
renderBundleEncoder28.draw(58, 2, 1_004_457_990);
} catch {}
try {
renderBundleEncoder28.drawIndirect(buffer34, 92);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline23);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(3); };
} catch {}
let pipelineLayout9 = device2.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout25]});
let commandEncoder213 = device2.createCommandEncoder({});
let texture258 = device2.createTexture({
  size: {width: 40, height: 23, depthOrArrayLayers: 5},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView235 = texture249.createView({dimension: '2d-array', mipLevelCount: 1});
let renderPassEncoder44 = commandEncoder213.beginRenderPass({
  colorAttachments: [{
  view: textureView226,
  clearValue: { r: -593.2, g: 473.5, b: 266.9, a: 321.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 212699793,
});
let textureView236 = texture88.createView({dimension: '2d'});
try {
renderBundleEncoder28.drawIndexed(1, 1, 0, 658_397_863);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(5, buffer0, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer69, 0, new DataView(new ArrayBuffer(23064)), 1459, 0);
} catch {}
document.body.append(canvas0);
let commandEncoder214 = device2.createCommandEncoder();
let textureView237 = texture252.createView({});
let renderBundleEncoder59 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], stencilReadOnly: true});
try {
commandEncoder214.insertDebugMarker('\ueaef');
} catch {}
try {
renderPassEncoder37.setVertexBuffer(0, buffer135, 0, 1);
} catch {}
try {
commandEncoder197.copyTextureToTexture({
  texture: texture227,
  mipLevel: 0,
  origin: {x: 34, y: 8, z: 0},
  aspect: 'all',
},
{
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer133, 36, new Uint32Array(59).map((_, i) => i * 2), 10, 0);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 75, height: 10, depthOrArrayLayers: 1}
*/
{
  source: imageData22,
  origin: { x: 0, y: 2 },
  flipY: false,
}, {
  texture: texture218,
  mipLevel: 3,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer171 = device0.createBuffer({size: 288, usage: GPUBufferUsage.INDEX});
let renderBundle20 = renderBundleEncoder28.finish({});
let sampler37 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.82,
  compare: 'always',
  maxAnisotropy: 1,
});
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder26.draw(128, 1, 341_072_166);
} catch {}
document.body.prepend(img2);
let textureView238 = texture258.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 0});
let texture259 = device2.createTexture({
  size: {width: 675, height: 165, depthOrArrayLayers: 14},
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder44.setVertexBuffer(4, undefined);
} catch {}
let textureView239 = texture232.createView({mipLevelCount: 1, baseArrayLayer: 12, arrayLayerCount: 2});
try {
renderPassEncoder35.setVertexBuffer(4, buffer126);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer139, 'uint32', 0, 4);
} catch {}
let promise28 = device1.queue.onSubmittedWorkDone();
try {
  await promise28;
} catch {}
let veryExplicitBindGroupLayout26 = device2.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 10, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 49,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 26, hasDynamicOffset: false },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 142, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 440,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let commandEncoder215 = device2.createCommandEncoder({});
let texture260 = device2.createTexture({
  size: [168, 41, 1],
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture261 = device2.createTexture({
  size: {width: 320, height: 188, depthOrArrayLayers: 5},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture28 = device2.importExternalTexture({source: videoFrame23, colorSpace: 'srgb'});
let imageData33 = new ImageData(44, 56);
let recycledExplicitBindGroupLayout12 = pipeline40.getBindGroupLayout(2);
let bindGroup131 = device1.createBindGroup({layout: recycledExplicitBindGroupLayout12, entries: [{binding: 1, resource: textureView167}]});
let commandEncoder216 = device1.createCommandEncoder({});
let renderBundleEncoder60 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float']});
try {
computePassEncoder50.setBindGroup(0, bindGroup109, new Uint32Array(2177), 180, 0);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline39);
} catch {}
try {
computePassEncoder52.insertDebugMarker('\u0c48');
} catch {}
let imageData34 = new ImageData(8, 88);
let commandEncoder217 = device0.createCommandEncoder({});
try {
renderPassEncoder9.setBindGroup(1, bindGroup79, new Uint32Array(331), 24, 0);
} catch {}
try {
renderPassEncoder11.drawIndexed(0, 71, 0, 115_546_301, 195_976_724);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer110, 0);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer32, 'uint16', 2, 51);
} catch {}
try {
renderBundleEncoder38.setVertexBuffer(0, buffer12, 16, 5);
} catch {}
let pipeline44 = device0.createComputePipeline({layout: pipelineLayout7, compute: {module: shaderModule5, entryPoint: 'compute3'}});
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.append(canvas1);
let recycledExplicitBindGroupLayout13 = pipeline2.getBindGroupLayout(0);
let bindGroup132 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 3, resource: {buffer: buffer101, size: 68}},
    {binding: 90, resource: textureView57},
    {binding: 2, resource: {buffer: buffer28}},
    {binding: 1, resource: externalTexture12},
    {binding: 0, resource: textureView51},
  ],
});
let textureView240 = texture254.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 1});
try {
computePassEncoder17.setBindGroup(3, bindGroup62, [0]);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder26.setBindGroup(1, bindGroup2, new Uint32Array(3671), 1_025, 0);
} catch {}
try {
renderPassEncoder11.draw(0, 229, 0, 726_506_185);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder29.setBindGroup(0, bindGroup41);
} catch {}
let buffer172 = device2.createBuffer({size: 131, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let sampler38 = device2.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.37,
  compare: 'not-equal',
  maxAnisotropy: 14,
});
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(27); };
} catch {}
let buffer173 = device1.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let computePassEncoder56 = commandEncoder197.beginComputePass({
  timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 385},
});
let sampler39 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMaxClamp: 93.09,
});
try {
computePassEncoder51.setBindGroup(1, bindGroup125, new Uint32Array(334), 68, 0);
} catch {}
try {
computePassEncoder39.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(0, buffer135);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let canvas2 = document.createElement('canvas');
let bindGroup133 = device2.createBindGroup({
  layout: veryExplicitBindGroupLayout25,
  entries: [
    {binding: 73, resource: {buffer: buffer172, size: 64}},
    {binding: 4, resource: textureView229},
    {binding: 58, resource: {buffer: buffer172, size: 44}},
    {binding: 420, resource: textureView225},
    {binding: 10, resource: sampler36},
    {binding: 440, resource: textureView237},
    {binding: 142, resource: externalTexture28},
    {binding: 49, resource: {buffer: buffer172, size: 28}},
  ],
});
let buffer174 = device2.createBuffer({size: 12, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let textureView241 = texture260.createView({});
let texture262 = device2.createTexture({size: {width: 168}, dimension: '1d', format: 'r16float', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder57 = commandEncoder215.beginComputePass();
let renderBundleEncoder61 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true, stencilReadOnly: true});
let bindGroup134 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 1, resource: externalTexture3},
    {binding: 0, resource: textureView1},
    {binding: 3, resource: {buffer: buffer98}},
    {binding: 2, resource: {buffer: buffer11}},
    {binding: 90, resource: textureView8},
  ],
});
let texture263 = device0.createTexture({
  size: {width: 744, height: 3, depthOrArrayLayers: 33},
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder26.draw(157, 1, 328_359_971);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer101, 16);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer75, 'uint16', 4, 8);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(3, buffer115, 0, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup68);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer71, 'uint16', 6, 45);
} catch {}
let gpuCanvasContext10 = canvas2.getContext('webgpu');
let commandEncoder218 = device2.createCommandEncoder({});
let querySet7 = device2.createQuerySet({type: 'timestamp', count: 802});
let renderBundleEncoder62 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true});
try {
device2.queue.writeTexture({
  texture: texture253,
  mipLevel: 0,
  origin: {x: 244, y: 66, z: 1},
  aspect: 'all',
}, new Uint8Array(102).fill(133), /* required buffer size: 102 */
{offset: 102}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout10 = device2.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout25, veryExplicitBindGroupLayout26]});
let computePassEncoder58 = commandEncoder218.beginComputePass();
let renderPassEncoder45 = commandEncoder214.beginRenderPass({colorAttachments: [{view: textureView226, loadOp: 'clear', storeOp: 'discard'}]});
try {
computePassEncoder57.setBindGroup(3, bindGroup133);
} catch {}
document.body.append(canvas1);
let bindGroup135 = device2.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 440, resource: textureView237},
    {binding: 58, resource: {buffer: buffer172, size: 48}},
    {binding: 73, resource: {buffer: buffer172, size: 96}},
    {binding: 142, resource: externalTexture28},
    {binding: 10, resource: sampler36},
    {binding: 420, resource: textureView228},
    {binding: 4, resource: textureView229},
    {binding: 49, resource: {buffer: buffer172, size: 32}},
  ],
});
let commandEncoder219 = device2.createCommandEncoder();
let renderPassEncoder46 = commandEncoder219.beginRenderPass({
  colorAttachments: [{
  view: textureView226,
  clearValue: { r: -784.9, g: -963.5, b: -139.4, a: -102.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet7, endOfPassWriteIndex: 55},
  maxDrawCount: 139188248,
});
let bindGroup136 = device2.createBindGroup({
  layout: veryExplicitBindGroupLayout25,
  entries: [
    {binding: 10, resource: sampler36},
    {binding: 4, resource: textureView229},
    {binding: 49, resource: {buffer: buffer172, size: 44}},
    {binding: 142, resource: externalTexture28},
    {binding: 420, resource: textureView225},
    {binding: 440, resource: textureView237},
    {binding: 58, resource: {buffer: buffer172, size: 48}},
    {binding: 73, resource: {buffer: buffer172, size: 64}},
  ],
});
let buffer175 = device2.createBuffer({
  size: 213,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let texture264 = gpuCanvasContext0.getCurrentTexture();
let textureView242 = texture246.createView({aspect: 'all', baseMipLevel: 0});
let renderBundleEncoder63 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true, stencilReadOnly: true});
let texture265 = device1.createTexture({
  size: {width: 600, height: 87, depthOrArrayLayers: 16},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView243 = texture200.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder46.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.drawIndexed(1, 4, 0, 504_517_597, 4);
} catch {}
try {
renderPassEncoder34.drawIndexedIndirect(buffer146, 72);
} catch {}
try {
renderPassEncoder34.drawIndirect(buffer144, 72);
} catch {}
try {
renderBundleEncoder34.setBindGroup(2, bindGroup121);
} catch {}
try {
renderBundleEncoder36.setBindGroup(1, bindGroup109, new Uint32Array(1006), 115, 0);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 600, height: 87, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture218,
  mipLevel: 0,
  origin: {x: 23, y: 83, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let imageData35 = new ImageData(24, 100);
let buffer176 = device1.createBuffer({size: 368, usage: GPUBufferUsage.COPY_SRC});
let computePassEncoder59 = commandEncoder200.beginComputePass();
try {
computePassEncoder50.setBindGroup(2, bindGroup127, new Uint32Array(159), 0, 0);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.drawIndirect(buffer146, 168);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer135, 'uint16', 24, 62);
} catch {}
let commandEncoder220 = device1.createCommandEncoder({});
let computePassEncoder60 = commandEncoder216.beginComputePass();
try {
computePassEncoder51.setBindGroup(2, bindGroup121, new Uint32Array(7184), 76, 0);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.draw(254, 2, 66_169_379, 5);
} catch {}
try {
renderPassEncoder34.drawIndexed(1, 14, 0, 75_790_622);
} catch {}
try {
commandEncoder209.copyTextureToTexture({
  texture: texture227,
  mipLevel: 0,
  origin: {x: 95, y: 10, z: 4},
  aspect: 'all',
},
{
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline45 = await device1.createRenderPipelineAsync({
  label: '\u5106\u{1fe5d}\u0f9e\u2be3\ud1c2\u{1f718}',
  layout: 'auto',
  fragment: {module: shaderModule8, targets: [{format: 'rg16float', writeMask: 0}]},
  vertex: {
    module: shaderModule11,
    constants: {},
    buffers: [
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 0, shaderLocation: 2},
          {format: 'float32x3', offset: 4, shaderLocation: 15},
          {format: 'float32x2', offset: 0, shaderLocation: 10},
          {format: 'float32x2', offset: 0, shaderLocation: 13},
          {format: 'sint16x2', offset: 36, shaderLocation: 11},
          {format: 'sint32', offset: 8, shaderLocation: 12},
          {format: 'float32', offset: 12, shaderLocation: 7},
          {format: 'uint32x4', offset: 0, shaderLocation: 3},
          {format: 'sint32', offset: 8, shaderLocation: 9},
          {format: 'sint32x2', offset: 8, shaderLocation: 5},
          {format: 'float16x4', offset: 0, shaderLocation: 6},
          {format: 'sint32', offset: 12, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 184,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint8x4', offset: 4, shaderLocation: 0},
          {format: 'unorm8x4', offset: 128, shaderLocation: 14},
          {format: 'uint8x2', offset: 18, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let commandEncoder221 = device1.createCommandEncoder({});
try {
computePassEncoder39.setBindGroup(0, bindGroup109);
} catch {}
try {
renderBundleEncoder44.setBindGroup(0, bindGroup117, new Uint32Array(2879), 501, 0);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer146, 'uint16', 144, 101);
} catch {}
document.body.append(canvas2);
let imageData36 = new ImageData(56, 24);
let bindGroup137 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 2, resource: {buffer: buffer61, offset: 0}},
    {binding: 0, resource: textureView51},
    {binding: 1, resource: externalTexture17},
    {binding: 90, resource: textureView57},
    {binding: 3, resource: {buffer: buffer28}},
  ],
});
let textureView244 = texture51.createView({});
let sampler40 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.46,
  maxAnisotropy: 14,
});
try {
renderPassEncoder9.setVertexBuffer(0, buffer142, 4, 54);
} catch {}
try {
renderBundleEncoder51.setBindGroup(1, bindGroup43);
} catch {}
let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt470bg', transfer: 'gamma28curve'} });
let buffer177 = device2.createBuffer({size: 152, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder222 = device2.createCommandEncoder();
try {
renderBundleEncoder52.setVertexBuffer(5, buffer177, 0, 14);
} catch {}
let texture266 = device1.createTexture({
  size: {width: 300, height: 43, depthOrArrayLayers: 1},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture267 = device1.createTexture({
  size: {width: 1200, height: 174, depthOrArrayLayers: 48},
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder52.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.draw(176, 4, 399_643_453, 2);
} catch {}
try {
renderBundleEncoder42.setBindGroup(2, bindGroup121, new Uint32Array(781), 3, 0);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer135, 'uint32', 0, 3);
} catch {}
try {
renderBundleEncoder49.setPipeline(pipeline45);
} catch {}
let veryExplicitBindGroupLayout27 = device2.createBindGroupLayout({
  label: '\ue3f9\ubf8e\u0a8b\u0804\u06f3\ub8e6',
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 58, hasDynamicOffset: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 141,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 154,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 208,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 289,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer178 = device2.createBuffer({size: 288, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder45.setVertexBuffer(0, buffer177, 4, 3);
} catch {}
try {
renderBundleEncoder63.setVertexBuffer(4, buffer177, 20);
} catch {}
let commandEncoder223 = device1.createCommandEncoder({});
let texture268 = device1.createTexture({
  size: [6, 60, 368],
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder61 = commandEncoder209.beginComputePass();
try {
computePassEncoder61.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.drawIndexed(1, 1, 0, 21_927_549);
} catch {}
try {
renderPassEncoder34.drawIndirect(buffer146, 0);
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline38);
} catch {}
try {
renderBundleEncoder50.setBindGroup(0, bindGroup127, new Uint32Array(122), 11, 0);
} catch {}
try {
renderBundleEncoder49.setIndexBuffer(buffer132, 'uint32', 8, 15);
} catch {}
try {
renderBundleEncoder49.setVertexBuffer(0, buffer147);
} catch {}
try {
device1.queue.writeBuffer(buffer173, 0, new Uint32Array(5243).map((_, i) => i * 9), 695, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView245 = texture266.createView({});
try {
computePassEncoder60.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.drawIndirect(buffer139, 28);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer135, 'uint32', 24, 79);
} catch {}
try {
renderPassEncoder37.setPipeline(pipeline38);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(5, buffer134, 16, 11);
} catch {}
try {
renderBundleEncoder44.setPipeline(pipeline40);
} catch {}
let commandEncoder224 = device1.createCommandEncoder();
let querySet8 = device1.createQuerySet({type: 'occlusion', count: 73});
let texture269 = device1.createTexture({
  size: [1200, 174, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder62 = commandEncoder220.beginComputePass({timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 134}});
try {
renderPassEncoder34.draw(59, 3, 985_153_302);
} catch {}
try {
renderPassEncoder37.drawIndexed(3, 0, 0, 932_562_217);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline40);
} catch {}
let textureView246 = texture252.createView({dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1});
let renderPassEncoder47 = commandEncoder222.beginRenderPass({
  colorAttachments: [{
  view: textureView242,
  clearValue: { r: -23.59, g: 249.6, b: 939.7, a: 378.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet7, endOfPassWriteIndex: 570},
  maxDrawCount: 703623273,
});
try {
renderBundleEncoder61.setVertexBuffer(2, buffer177, 0, 22);
} catch {}
await gc();
let texture270 = device1.createTexture({
  size: [600, 87, 58],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder64 = device1.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true});
let externalTexture29 = device1.importExternalTexture({source: videoFrame0});
try {
computePassEncoder51.setBindGroup(0, bindGroup121, new Uint32Array(318), 18, 0);
} catch {}
try {
computePassEncoder62.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder34.drawIndirect(buffer146, 36);
} catch {}
try {
renderBundleEncoder36.setBindGroup(3, bindGroup109, new Uint32Array(3117), 136, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer134, 28, new Uint32Array(6450).map((_, i) => i * 1), 1254, 0);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let buffer179 = device2.createBuffer({size: 120, usage: GPUBufferUsage.INDEX});
let texture271 = device2.createTexture({
  size: {width: 337, height: 82, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture272 = gpuCanvasContext3.getCurrentTexture();
let textureView247 = texture249.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1});
let sampler41 = device2.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.48,
  maxAnisotropy: 14,
});
try {
renderPassEncoder42.setIndexBuffer(buffer179, 'uint16', 4, 8);
} catch {}
try {
device2.lost.then(({reason, message}) => { console.log('device2 lost!'); console.log(message, reason); });
} catch {}
let promise29 = device2.queue.onSubmittedWorkDone();
let buffer180 = device0.createBuffer({size: 4, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, mappedAtCreation: false});
let textureView248 = texture123.createView({mipLevelCount: 1});
try {
computePassEncoder9.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer101, 60);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer101, 4);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer30, 104, 44);
} catch {}
try {
commandEncoder211.copyBufferToTexture({
  /* bytesInLastRow: 1376 widthInBlocks: 86 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1504 */
  offset: 1504,
  bytesPerRow: 17408,
  buffer: buffer2,
}, {
  texture: texture88,
  mipLevel: 0,
  origin: {x: 139, y: 31, z: 0},
  aspect: 'all',
}, {width: 86, height: 44, depthOrArrayLayers: 0});
} catch {}
let commandEncoder225 = device1.createCommandEncoder({});
let textureView249 = texture270.createView({baseArrayLayer: 41, arrayLayerCount: 4});
let texture273 = device1.createTexture({
  size: {width: 1, height: 15, depthOrArrayLayers: 66},
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView250 = texture194.createView({baseArrayLayer: 1, arrayLayerCount: 3});
try {
renderPassEncoder35.setBindGroup(1, bindGroup131);
} catch {}
try {
renderPassEncoder39.setBindGroup(1, bindGroup127, new Uint32Array(8947), 450, 0);
} catch {}
try {
renderPassEncoder34.drawIndirect(buffer160, 12);
} catch {}
try {
renderBundleEncoder39.setBindGroup(2, bindGroup131, new Uint32Array(652), 15, 0);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(5, buffer135, 40, 17);
} catch {}
let pipeline46 = await device1.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule8,
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'zero', dstFactor: 'src-alpha-saturated'},
  },
}],
},
  vertex: {
    module: shaderModule8,
    buffers: [{arrayStride: 32, attributes: [{format: 'sint32x2', offset: 0, shaderLocation: 9}]}],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', cullMode: 'back'},
});
let commandEncoder226 = device2.createCommandEncoder({});
let texture274 = device2.createTexture({
  size: {width: 168, height: 41, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder226.copyBufferToBuffer(buffer174, 0, buffer178, 8, 0);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let commandBuffer31 = commandEncoder32.finish();
let textureView251 = texture235.createView({dimension: '2d-array'});
let texture275 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 20},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder57.setIndexBuffer(buffer86, 'uint32', 40, 91);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 372, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture159,
  mipLevel: 0,
  origin: {x: 99, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture26.label;
} catch {}
let bindGroup138 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 11, resource: textureView207}, {binding: 2, resource: textureView204}],
});
let commandEncoder227 = device1.createCommandEncoder({});
try {
renderPassEncoder38.setIndexBuffer(buffer146, 'uint16', 30, 84);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(2, buffer134, 28);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device1.queue.writeBuffer(buffer134, 0, new Float32Array(4467).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.745)), 515, 8);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let autogeneratedBindGroupLayout11 = pipeline31.getBindGroupLayout(1);
let commandBuffer32 = commandEncoder11.finish();
try {
renderPassEncoder31.executeBundles([renderBundle18, renderBundle6, renderBundle1]);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer101, 56);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer163, 'uint32', 4, 26);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(5, buffer13, 0, 0);
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline34);
} catch {}
let imageData37 = new ImageData(8, 4);
let bindGroup139 = device2.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 10, resource: sampler41},
    {binding: 142, resource: externalTexture28},
    {binding: 73, resource: {buffer: buffer172, size: 80}},
    {binding: 58, resource: {buffer: buffer172, size: 56}},
    {binding: 49, resource: {buffer: buffer172, size: 32}},
    {binding: 440, resource: textureView237},
    {binding: 4, resource: textureView229},
    {binding: 420, resource: textureView225},
  ],
});
let textureView252 = texture260.createView({});
let computePassEncoder63 = commandEncoder226.beginComputePass({timestampWrites: {querySet: querySet7}});
try {
computePassEncoder63.setBindGroup(0, bindGroup133);
} catch {}
try {
renderPassEncoder44.setIndexBuffer(buffer179, 'uint32', 12, 3);
} catch {}
try {
renderBundleEncoder54.setIndexBuffer(buffer179, 'uint32', 40, 4);
} catch {}
try {
renderBundleEncoder52.setVertexBuffer(7, buffer177, 8);
} catch {}
let texture276 = device1.createTexture({
  size: [600, 87, 1],
  mipLevelCount: 2,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder48 = commandEncoder227.beginRenderPass({
  colorAttachments: [{
  view: textureView233,
  depthSlice: 5,
  clearValue: { r: 633.4, g: 778.4, b: -904.8, a: -514.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 140},
});
try {
computePassEncoder39.setBindGroup(1, bindGroup117, new Uint32Array(826), 419, 0);
} catch {}
try {
renderPassEncoder39.setBindGroup(3, bindGroup127, new Uint32Array(132), 34, 0);
} catch {}
try {
renderPassEncoder37.drawIndexedIndirect(buffer160, 8);
} catch {}
try {
renderBundleEncoder45.setIndexBuffer(buffer146, 'uint16', 36, 34);
} catch {}
try {
commandEncoder210.copyTextureToTexture({
  texture: texture209,
  mipLevel: 0,
  origin: {x: 18, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture209,
  mipLevel: 0,
  origin: {x: 474, y: 27, z: 1},
  aspect: 'all',
},
{width: 33, height: 13, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder48.insertDebugMarker('\u86dd');
} catch {}
try {
device1.queue.writeBuffer(buffer134, 8, new Float32Array(8596).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.788)), 1923, 0);
} catch {}
let commandEncoder228 = device0.createCommandEncoder();
let sampler42 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
});
try {
renderPassEncoder26.drawIndexedIndirect(buffer77, 48);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder51.setPipeline(pipeline24);
} catch {}
try {
device0.queue.writeBuffer(buffer69, 0, new DataView(new ArrayBuffer(26494)), 2444, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 372, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData18,
  origin: { x: 10, y: 1 },
  flipY: false,
}, {
  texture: texture159,
  mipLevel: 0,
  origin: {x: 75, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView253 = texture200.createView({aspect: 'all'});
let texture277 = device1.createTexture({
  size: {width: 1, height: 15, depthOrArrayLayers: 66},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
gpuCanvasContext2.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device1.queue.writeBuffer(buffer134, 0, new Uint16Array(16048).map((_, i) => i + 1), 929, 4);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device2.queue.label = '\u{1fd6d}\u67dc\u6c2b\ud9eb\u118a\ue2ba\u{1f9a1}';
} catch {}
let commandEncoder229 = device2.createCommandEncoder({});
let textureView254 = texture247.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6});
let renderBundleEncoder65 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], stencilReadOnly: true});
try {
device2.queue.writeBuffer(buffer178, 8, new DataView(new Uint8Array(17086).map((_, i) => i).buffer), 2176, 220);
} catch {}
let textureView255 = texture233.createView({dimension: '2d-array', baseArrayLayer: 10, arrayLayerCount: 1});
try {
computePassEncoder61.setBindGroup(3, bindGroup127);
} catch {}
try {
renderPassEncoder37.drawIndexed(3, 0, 0, 55_026_168);
} catch {}
try {
renderPassEncoder37.drawIndexedIndirect(buffer160, 4);
} catch {}
try {
renderBundleEncoder50.setBindGroup(1, bindGroup125, new Uint32Array(2149), 386, 0);
} catch {}
try {
renderBundleEncoder50.setVertexBuffer(4, buffer145, 56);
} catch {}
let bindGroup140 = device2.createBindGroup({
  layout: veryExplicitBindGroupLayout26,
  entries: [
    {binding: 4, resource: textureView229},
    {binding: 49, resource: {buffer: buffer172, size: 76}},
    {binding: 73, resource: {buffer: buffer172, offset: 0, size: 92}},
    {binding: 440, resource: textureView237},
    {binding: 58, resource: {buffer: buffer172, size: 48}},
    {binding: 10, resource: sampler41},
    {binding: 420, resource: textureView225},
    {binding: 142, resource: externalTexture28},
  ],
});
let texture278 = device2.createTexture({size: {width: 64}, dimension: '1d', format: 'r16float', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder46.setVertexBuffer(4, buffer177);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(3, buffer177, 60, 10);
} catch {}
try {
renderBundleEncoder63.insertDebugMarker('\u{1f969}');
} catch {}
let bindGroup141 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 3, resource: {buffer: buffer76}},
    {binding: 0, resource: textureView51},
    {binding: 2, resource: {buffer: buffer74, size: 12}},
    {binding: 90, resource: textureView43},
    {binding: 1, resource: externalTexture18},
  ],
});
let computePassEncoder64 = commandEncoder155.beginComputePass();
let sampler43 = device0.createSampler({addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 81.97, compare: 'always'});
let buffer181 = device2.createBuffer({size: 52, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
try {
computePassEncoder57.setBindGroup(3, bindGroup136, new Uint32Array(386), 154, 0);
} catch {}
let texture279 = device2.createTexture({
  size: [40, 23, 5],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder49 = commandEncoder229.beginRenderPass({
  colorAttachments: [{
  view: textureView226,
  clearValue: { r: -129.7, g: -929.5, b: 478.2, a: -68.32, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 338454982,
});
let renderBundle21 = renderBundleEncoder63.finish({});
try {
renderBundleEncoder52.setVertexBuffer(7, buffer177, 0);
} catch {}
try {
device2.lost.then(({reason, message}) => { console.log('device2 lost!'); console.log(message, reason); });
} catch {}
try {
buffer179.unmap();
} catch {}
let veryExplicitBindGroupLayout28 = device2.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 10, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 49,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 26, hasDynamicOffset: false },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 142, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 440,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let textureView256 = texture259.createView({baseArrayLayer: 0});
let externalTexture30 = device2.importExternalTexture({source: videoFrame32});
try {
renderBundleEncoder62.setIndexBuffer(buffer179, 'uint32', 4, 5);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let bindGroup142 = device2.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 58, resource: {buffer: buffer172, size: 52}},
    {binding: 49, resource: {buffer: buffer172, size: 36}},
    {binding: 440, resource: textureView237},
    {binding: 73, resource: {buffer: buffer172, size: 72}},
    {binding: 142, resource: externalTexture28},
    {binding: 420, resource: textureView228},
    {binding: 10, resource: sampler36},
    {binding: 4, resource: textureView229},
  ],
});
let textureView257 = texture247.createView({dimension: 'cube-array', aspect: 'depth-only', baseArrayLayer: 1, arrayLayerCount: 6});
try {
computePassEncoder58.setBindGroup(2, bindGroup142, new Uint32Array(4547), 234, 0);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer181, 'uint32', 0, 2);
} catch {}
let commandBuffer33 = commandEncoder31.finish();
try {
renderPassEncoder28.setBindGroup(1, bindGroup115);
} catch {}
try {
renderPassEncoder23.end();
} catch {}
try {
renderPassEncoder4.draw(19, 0, 418_959_979);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer72, 300);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer72, 'uint16', 690, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup106, [0, 0, 0]);
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline9);
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(32); };
} catch {}
let commandEncoder230 = device1.createCommandEncoder({});
let textureView258 = texture213.createView({dimension: '2d-array'});
let textureView259 = texture213.createView({dimension: '2d-array', format: 'rgba32sint', mipLevelCount: 1});
let renderBundleEncoder66 = device1.createRenderBundleEncoder({colorFormats: ['rg16float']});
try {
computePassEncoder60.setBindGroup(1, bindGroup131, new Uint32Array(268), 116, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(3, bindGroup138, new Uint32Array(1573), 253, 0);
} catch {}
try {
renderPassEncoder37.drawIndirect(buffer146, 60);
} catch {}
try {
renderBundleEncoder42.setPipeline(pipeline45);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let imageData38 = new ImageData(24, 16);
let textureView260 = texture240.createView({baseMipLevel: 0});
try {
renderPassEncoder39.setBindGroup(2, bindGroup121, new Uint32Array(1259), 396, 0);
} catch {}
try {
renderPassEncoder37.draw(282, 0, 1_668_255_443);
} catch {}
try {
renderPassEncoder34.drawIndexed(1, 1, 0, 700_417_209, 6);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline40);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(4, buffer147, 148, 26);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(6, buffer126, 0, 6);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
document.body.append(canvas1);
let commandEncoder231 = device0.createCommandEncoder({});
let textureView261 = texture251.createView({});
try {
computePassEncoder64.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup134, new Uint32Array(1827), 1_395, 0);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 399_553_228);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer78, 4);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer116, 4);
} catch {}
try {
renderBundleEncoder48.setVertexBuffer(7, buffer106, 0);
} catch {}
try {
commandEncoder102.copyTextureToBuffer({
  texture: texture223,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1586 */
  offset: 1586,
  buffer: buffer11,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 11}
*/
{
  source: imageData4,
  origin: { x: 0, y: 9 },
  flipY: true,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 27, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise29;
} catch {}
let bindGroup143 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [
    {binding: 5, resource: textureView108},
    {binding: 8, resource: {buffer: buffer98, size: 176}},
    {binding: 11, resource: textureView21},
    {binding: 3, resource: textureView79},
    {binding: 0, resource: {buffer: buffer161}},
    {binding: 407, resource: {buffer: buffer1}},
  ],
});
try {
renderPassEncoder26.drawIndexed(12, 1, 2, 272_478_481);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline41);
} catch {}
try {
renderBundleEncoder32.setBindGroup(3, bindGroup93, new Uint32Array(1054), 52, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2976, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData35,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture150,
  mipLevel: 0,
  origin: {x: 127, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline47 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{format: 'r16uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex5',
    constants: {},
    buffers: [
      {
        arrayStride: 12,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 0, shaderLocation: 15},
          {format: 'snorm8x4', offset: 0, shaderLocation: 9},
          {format: 'sint16x2', offset: 0, shaderLocation: 14},
          {format: 'sint16x4', offset: 0, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7},
          {format: 'float32x2', offset: 0, shaderLocation: 12},
          {format: 'snorm8x2', offset: 0, shaderLocation: 3},
          {format: 'uint32x2', offset: 0, shaderLocation: 0},
          {format: 'uint32', offset: 0, shaderLocation: 5},
          {format: 'unorm16x4', offset: 0, shaderLocation: 13},
          {format: 'uint8x4', offset: 0, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 8,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x2', offset: 0, shaderLocation: 10},
          {format: 'snorm16x4', offset: 0, shaderLocation: 8},
          {format: 'snorm16x2', offset: 0, shaderLocation: 2},
          {format: 'float32x2', offset: 0, shaderLocation: 1},
          {format: 'unorm16x2', offset: 0, shaderLocation: 4},
        ],
      },
    ],
  },
});
let commandEncoder232 = device2.createCommandEncoder({});
let textureView262 = texture258.createView({arrayLayerCount: 1});
let externalTexture31 = device2.importExternalTexture({source: videoFrame8});
try {
gpuCanvasContext8.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let buffer182 = device2.createBuffer({size: 160, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let texture280 = device2.createTexture({
  size: {width: 337, height: 82, depthOrArrayLayers: 445},
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderBundleEncoder67 = device2.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder55.setBindGroup(3, bindGroup142);
} catch {}
try {
renderPassEncoder49.setIndexBuffer(buffer179, 'uint16', 20, 10);
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(85); };
} catch {}
let externalTexture32 = device2.importExternalTexture({source: videoFrame17});
try {
computePassEncoder57.setBindGroup(3, bindGroup139, new Uint32Array(1168), 312, 0);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(0, buffer177, 0, 89);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 337, height: 82, depthOrArrayLayers: 445}
*/
{
  source: imageData21,
  origin: { x: 0, y: 21 },
  flipY: true,
}, {
  texture: texture280,
  mipLevel: 0,
  origin: {x: 99, y: 7, z: 27},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 17, height: 8, depthOrArrayLayers: 0});
} catch {}
let commandEncoder233 = device1.createCommandEncoder({});
let texture281 = gpuCanvasContext8.getCurrentTexture();
try {
computePassEncoder60.setBindGroup(0, bindGroup131, new Uint32Array(1406), 4, 0);
} catch {}
try {
renderPassEncoder37.draw(68, 0, 657_245_972);
} catch {}
try {
renderPassEncoder34.drawIndexedIndirect(buffer169, 64);
} catch {}
try {
renderPassEncoder37.drawIndirect(buffer144, 12);
} catch {}
try {
renderBundleEncoder60.setPipeline(pipeline42);
} catch {}
try {
renderBundleEncoder39.setVertexBuffer(0, buffer133, 0, 0);
} catch {}
document.body.append(canvas1);
await gc();
let bindGroup144 = device2.createBindGroup({
  layout: veryExplicitBindGroupLayout25,
  entries: [
    {binding: 49, resource: {buffer: buffer172, offset: 0, size: 64}},
    {binding: 4, resource: textureView229},
    {binding: 142, resource: externalTexture28},
    {binding: 10, resource: sampler36},
    {binding: 440, resource: textureView237},
    {binding: 58, resource: {buffer: buffer172, size: 64}},
    {binding: 420, resource: textureView225},
    {binding: 73, resource: {buffer: buffer172, offset: 0, size: 92}},
  ],
});
let textureView263 = texture279.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder55.setBindGroup(3, bindGroup142, new Uint32Array(2548), 134, 0);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer181, 'uint32', 20, 6);
} catch {}
try {
renderBundleEncoder55.setIndexBuffer(buffer179, 'uint16', 10, 24);
} catch {}
let bindGroup145 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 2, resource: {buffer: buffer117}}]});
try {
renderPassEncoder26.drawIndirect(buffer39, 88);
} catch {}
try {
buffer52.unmap();
} catch {}
try {
commandEncoder150.insertDebugMarker('\u0897');
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\ua714');
} catch {}
try {
device0.queue.submit([commandBuffer32, commandBuffer31, commandBuffer33]);
} catch {}
let texture282 = gpuCanvasContext9.getCurrentTexture();
let textureView264 = texture21.createView({});
try {
renderPassEncoder26.draw(125, 1, 256_796_289);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer120, 2_760);
} catch {}
try {
renderBundleEncoder57.setBindGroup(2, bindGroup9);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let bindGroup146 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 1, resource: externalTexture18},
    {binding: 3, resource: {buffer: buffer28, size: 88}},
    {binding: 0, resource: textureView0},
    {binding: 2, resource: {buffer: buffer76}},
    {binding: 90, resource: textureView43},
  ],
});
let buffer183 = device0.createBuffer({size: 444, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder234 = device0.createCommandEncoder({});
let textureView265 = texture119.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 177_558_177);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer39, 0);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer21, 0);
} catch {}
try {
buffer69.unmap();
} catch {}
await gc();
let textureView266 = texture120.createView({dimension: '2d-array', mipLevelCount: 2});
try {
renderPassEncoder26.draw(70, 1, 52_404_071);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer18, 'uint16', 10, 11);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer161, 20, new DataView(new Uint8Array(5879).map((_, i) => i).buffer), 981, 0);
} catch {}
let pipeline48 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}});
let renderBundleEncoder68 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float'], stencilReadOnly: true});
try {
renderPassEncoder39.setBindGroup(0, bindGroup117);
} catch {}
try {
renderPassEncoder34.drawIndexed(1, 9, 0, 336_740_701, 6);
} catch {}
try {
renderPassEncoder37.drawIndexedIndirect(buffer139, 0);
} catch {}
try {
buffer140.unmap();
} catch {}
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame5.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
videoFrame19.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
videoFrame27.close();
videoFrame31.close();
videoFrame32.close();
}

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

  let workers = [

  ];
  let promises = [ window0() ];
  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>