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

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?.dumpAsText();
globalThis.testRunner?.waitUntilDone();


async function window0() {
let adapter0 = await navigator.gpu.requestAdapter();
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxVertexBufferArrayStride: 2048,
    maxUniformBufferBindingSize: 232505090,
    maxStorageBufferBindingSize: 151243586,
  },
});
let imageData0 = new ImageData(4, 56);
let commandEncoder0 = device0.createCommandEncoder({});
let sampler0 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 17.28,
  lodMaxClamp: 64.33,
  compare: 'not-equal',
});
let bindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 37,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 285,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer0 = device0.createBuffer({size: 2961, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder1 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  label: '\u{1fedc}\ue089\u{1f81d}\ud872\u08aa\u037c\uabc2\u914e\u{1f85b}\u0b6e',
  size: {width: 55},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder0 = commandEncoder1.beginComputePass({});
try {
commandEncoder0.copyTextureToBuffer({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 640 */
  offset: 640,
  bytesPerRow: 24320,
  buffer: buffer0,
}, {width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap0 = await createImageBitmap(imageData0);
let bindGroupLayout1 = device0.createBindGroupLayout({entries: []});
let buffer1 = device0.createBuffer({size: 12933, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder2 = device0.createCommandEncoder({});
let texture1 = device0.createTexture({
  size: [26],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder1 = commandEncoder2.beginComputePass({});
try {
buffer1.unmap();
} catch {}
let bindGroup0 = device0.createBindGroup({label: '\u{1fe60}\ucd58', layout: bindGroupLayout1, entries: []});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView0 = texture0.createView({label: '\u022a\u0799\u025a\u4fe0\u{1fed0}\u6b68\u6c45\u04e6\u6c7e'});
let texture2 = device0.createTexture({
  size: [52, 40, 106],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint', 'rg8uint'],
});
try {
computePassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
let buffer2 = device0.createBuffer({
  size: 17168,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder3 = device0.createCommandEncoder({});
try {
commandEncoder3.copyBufferToBuffer(buffer2, 2168, buffer1, 916, 7136);
} catch {}
try {
commandEncoder2.label = '\u4312\u{1fb8f}';
} catch {}
let bindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 49,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 134, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let texture3 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 121},
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture4 = device0.createTexture({
  size: {width: 13},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder2 = commandEncoder3.beginComputePass({});
let sampler1 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 50.54,
  lodMaxClamp: 79.61,
});
try {
computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(3440), 171, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
let buffer3 = device0.createBuffer({
  label: '\u0394\u3cf4\u0b88\u0d0a\u7b39\u{1ff13}\u{1ff72}',
  size: 303,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView1 = texture3.createView({dimension: '2d', baseArrayLayer: 4});
let computePassEncoder3 = commandEncoder0.beginComputePass();
let promise0 = device0.queue.onSubmittedWorkDone();
try {
commandEncoder0.label = '\u3f04\u5066\u0830\u07c6';
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout1]});
let texture5 = device0.createTexture({
  size: [1290, 8, 10],
  mipLevelCount: 8,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler2 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 89.54,
  lodMaxClamp: 92.16,
});
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(144).fill(211), /* required buffer size: 144 */
{offset: 144}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer4 = device0.createBuffer({
  size: 1701,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder4 = device0.createCommandEncoder({});
let computePassEncoder4 = commandEncoder4.beginComputePass({});
try {
computePassEncoder4.setBindGroup(2, bindGroup0, new Uint32Array(2626), 299, 0);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
computePassEncoder3.insertDebugMarker('\u0a60');
} catch {}
try {
device0.queue.writeBuffer(buffer0, 824, new BigUint64Array(1713), 183, 32);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 9, z: 9},
  aspect: 'depth-only',
}, new Uint8Array(221_540).fill(17), /* required buffer size: 221_540 */
{offset: 464, bytesPerRow: 207, rowsPerImage: 89}, {width: 52, height: 0, depthOrArrayLayers: 13});
} catch {}
let commandEncoder5 = device0.createCommandEncoder({});
let texture6 = device0.createTexture({
  size: [13],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView2 = texture2.createView({dimension: '2d-array', format: 'rg8uint', baseArrayLayer: 58, arrayLayerCount: 9});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
let renderBundle0 = renderBundleEncoder0.finish({});
let sampler3 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMaxClamp: 82.22,
});
let bindGroup1 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView0},
    {binding: 285, resource: {buffer: buffer1, offset: 4864, size: 3684}},
  ],
});
let texture7 = device0.createTexture({
  size: [110],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder5 = commandEncoder5.beginComputePass({});
try {
computePassEncoder5.setBindGroup(0, bindGroup1, new Uint32Array(2201), 516, 0);
} catch {}
try {
adapter0.label = '\u5fd3\u064b\u{1f9b6}\ua191';
} catch {}
let buffer5 = device0.createBuffer({
  label: '\u8ccd\u4bf7\u{1fa54}\u3b5f',
  size: 9980,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
  await promise0;
} catch {}
await gc();
let buffer6 = device0.createBuffer({
  label: '\u{1fada}\u{1fb5b}\ub3ec\u01bc\u8052\u066e\u02f9\u{1ffb4}',
  size: 32654,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder6 = device0.createCommandEncoder({});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 564});
let sampler4 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMinClamp: 42.72,
  lodMaxClamp: 67.93,
});
try {
computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(1243), 85, 0);
} catch {}
let imageData1 = new ImageData(4, 56);
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteRp431', transfer: 'hlg'} });
let textureView3 = texture3.createView({dimension: '2d', baseArrayLayer: 45});
try {
computePassEncoder2.setBindGroup(1, bindGroup0);
} catch {}
try {
commandEncoder6.copyTextureToBuffer({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 48 */
  offset: 48,
  buffer: buffer0,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(98).fill(66), /* required buffer size: 98 */
{offset: 98}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let buffer7 = device0.createBuffer({size: 1704, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let texture8 = device0.createTexture({size: {width: 52}, sampleCount: 1, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder6 = commandEncoder6.beginComputePass();
try {
computePassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(5747), 1_148, 0);
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 37, resource: textureView0}, {binding: 285, resource: {buffer: buffer5, offset: 4864}}],
});
let texture9 = device0.createTexture({size: [27, 4, 108], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder6.setBindGroup(0, bindGroup0, new Uint32Array(568), 59, 0);
} catch {}
let texture10 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 1},
  format: 'eac-r11unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView4 = texture10.createView({dimension: '2d-array'});
try {
computePassEncoder2.setBindGroup(1, bindGroup1);
} catch {}
try {
computePassEncoder1.setBindGroup(1, bindGroup1, new Uint32Array(1720), 202, 0);
} catch {}
try {
buffer5.unmap();
} catch {}
await gc();
let texture11 = device0.createTexture({
  size: {width: 2},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(1007), 142, 0);
} catch {}
let commandEncoder7 = device0.createCommandEncoder();
let sampler5 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  lodMinClamp: 78.09,
  lodMaxClamp: 95.83,
  maxAnisotropy: 1,
});
try {
computePassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(19), 3, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder7.clearBuffer(buffer3, 32, 20);
} catch {}
let commandEncoder8 = device0.createCommandEncoder({});
let textureView5 = texture1.createView({});
let sampler6 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 66.02,
  lodMaxClamp: 83.44,
});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer3, 140, buffer0, 56, 44);
} catch {}
try {
commandEncoder7.copyTextureToTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let texture12 = device0.createTexture({size: [161, 1, 1], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder4.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder4.setBindGroup(3, bindGroup1, new Uint32Array(546), 28, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer8 = device0.createBuffer({
  size: 20168,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView6 = texture10.createView({dimension: '2d-array'});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, stencilReadOnly: true});
try {
renderBundleEncoder1.setBindGroup(2, bindGroup0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer1, 'uint16', 296, 1_122);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 96, new DataView(new ArrayBuffer(30061)), 8694, 12);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder10 = device0.createCommandEncoder({});
let textureView7 = texture5.createView({dimension: '2d-array', format: 'rg8uint', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder7 = commandEncoder7.beginComputePass({});
try {
commandEncoder9.copyBufferToBuffer(buffer3, 28, buffer6, 7964, 20);
} catch {}
let buffer9 = device0.createBuffer({
  size: 6466,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let sampler7 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 36.44,
  lodMaxClamp: 44.74,
  compare: 'less-equal',
});
let texture13 = device0.createTexture({
  size: [55, 8, 312],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView8 = texture8.createView({dimension: '1d', mipLevelCount: 1});
let computePassEncoder8 = commandEncoder10.beginComputePass({});
try {
renderBundleEncoder1.setIndexBuffer(buffer3, 'uint16', 130, 46);
} catch {}
try {
commandEncoder9.copyTextureToBuffer({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 498 */
  offset: 498,
  bytesPerRow: 43008,
  buffer: buffer9,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView9 = texture1.createView({});
let computePassEncoder9 = commandEncoder9.beginComputePass({});
try {
computePassEncoder3.setBindGroup(1, bindGroup1, []);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup1, new Uint32Array(753), 154, 0);
} catch {}
let computePassEncoder10 = commandEncoder8.beginComputePass({});
try {
renderBundleEncoder1.setIndexBuffer(buffer9, 'uint32', 132, 1_570);
} catch {}
let buffer10 = device0.createBuffer({
  label: '\u356e\u{1fe84}\u276a\u4caa\u0925\u{1f767}\u619f\u{1f65e}\ude60\u25c5\u{1f615}',
  size: 13899,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let querySet1 = device0.createQuerySet({label: '\u03de\u{1fe11}\u124e\ud45d\u8aa4\u{1fd87}\u05f5\u{1fef3}', type: 'occlusion', count: 3143});
let texture14 = device0.createTexture({
  label: '\u0d60\u0301\ucdc0\u{1fd8d}\u0e36\uc789\u0bfd\u7656',
  size: {width: 55},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView10 = texture2.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 9});
let renderBundle1 = renderBundleEncoder1.finish({});
try {
computePassEncoder7.setBindGroup(0, bindGroup0, new Uint32Array(1151), 114, 0);
} catch {}
let commandEncoder11 = device0.createCommandEncoder({label: '\u1761\uceb1\u898e\ua4b9\ud74d\u0ca5\u0ab2'});
let renderPassEncoder0 = commandEncoder11.beginRenderPass({
  colorAttachments: [{view: textureView10, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 201416227,
});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({label: '\u{1fe1d}\u0180\u79fd', colorFormats: ['rg8uint'], depthReadOnly: true});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'display-p3'});
try {
computePassEncoder8.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(7, buffer6);
} catch {}
try {
buffer0.unmap();
} catch {}
let commandEncoder12 = device0.createCommandEncoder({});
let renderPassEncoder1 = commandEncoder12.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 108.5, g: -819.1, b: -96.00, a: 812.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 230812843,
});
try {
renderPassEncoder0.executeBundles([renderBundle0, renderBundle1]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer3, 'uint32', 60, 29);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup1, new Uint32Array(2458), 230, 0);
} catch {}
let bindGroup3 = device0.createBindGroup({
  label: '\u{1f706}\u048c\u68d6\ud814\ufa1d\uc707\u095b\u0923\u{1f9b4}\u0c7c\u920f',
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer10, offset: 6144, size: 4304}},
    {binding: 37, resource: textureView5},
  ],
});
let commandEncoder13 = device0.createCommandEncoder({});
let computePassEncoder11 = commandEncoder13.beginComputePass();
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
let renderBundle2 = renderBundleEncoder3.finish({});
try {
renderPassEncoder0.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 2_118, 6_797);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer6);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(1841), 138, 0);
} catch {}
let bindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 593,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '3d' },
    },
  ],
});
let buffer11 = device0.createBuffer({
  label: '\u9dee\u{1fcd4}\u{1fbbb}\u{1f802}\u{1fb35}\u06b7\ufd8c',
  size: 7407,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture15 = device0.createTexture({
  size: [2, 2, 45],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle3 = renderBundleEncoder2.finish({label: '\u7ac0\u{1fbeb}\u3876\u3f45\u0dda\u099d\u0842\u0491\u09af'});
try {
renderPassEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(5784), 2_570, 0);
} catch {}
try {
buffer5.unmap();
} catch {}
let commandEncoder14 = device0.createCommandEncoder({});
let textureView11 = texture15.createView({});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder10.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder5.setBindGroup(1, bindGroup0, new Uint32Array(622), 389, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup3);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint32', 528, 1_367);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer2, 0, 268);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(6, buffer3, 160);
} catch {}
let bindGroup4 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView11}]});
let textureView12 = texture5.createView({dimension: '2d', mipLevelCount: 2, baseArrayLayer: 1});
let renderPassEncoder2 = commandEncoder14.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -785.8, g: -224.2, b: -305.4, a: 924.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler8 = device0.createSampler({addressModeV: 'clamp-to-edge', magFilter: 'linear', lodMinClamp: 11.61, lodMaxClamp: 62.39});
try {
computePassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(214), 42, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer8, 'uint16', 8_910, 1_351);
} catch {}
try {
renderBundleEncoder4.setBindGroup(2, bindGroup1);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 12, new DataView(new ArrayBuffer(12247)), 842, 0);
} catch {}
let bindGroup5 = device0.createBindGroup({
  label: '\u03d8\u6482\uf36c\uc1ae\uefb7\ucc30\u788a\u{1f944}\ue71d\u{1fc53}\u{1fd70}',
  layout: bindGroupLayout2,
  entries: [{binding: 134, resource: externalTexture0}, {binding: 49, resource: textureView3}],
});
let commandEncoder15 = device0.createCommandEncoder();
let texture16 = device0.createTexture({
  size: [52],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle4 = renderBundleEncoder4.finish({});
try {
renderPassEncoder0.setBindGroup(1, bindGroup0, new Uint32Array(1995), 150, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer8, 'uint32', 428, 2_697);
} catch {}
try {
commandEncoder15.copyBufferToBuffer(buffer11, 1148, buffer6, 3352, 2988);
} catch {}
try {
commandEncoder15.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 558 */
  offset: 558,
  bytesPerRow: 18432,
  rowsPerImage: 275,
  buffer: buffer4,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder15.copyTextureToBuffer({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 724 */
  offset: 724,
  bytesPerRow: 32768,
  buffer: buffer6,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let commandEncoder16 = device0.createCommandEncoder({});
let texture17 = device0.createTexture({
  size: [55, 8, 312],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture18 = device0.createTexture({
  label: '\ua1d8\u1c10',
  size: {width: 27},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView13 = texture16.createView({format: 'rg8uint', baseArrayLayer: 0});
let computePassEncoder12 = commandEncoder16.beginComputePass({});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder15.copyBufferToBuffer(buffer2, 1024, buffer6, 12672, 1632);
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView14 = texture17.createView({baseMipLevel: 0, arrayLayerCount: 1});
let computePassEncoder13 = commandEncoder15.beginComputePass({});
try {
computePassEncoder0.setBindGroup(1, bindGroup3, new Uint32Array(1329), 493, 0);
} catch {}
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let textureView15 = texture2.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 44, arrayLayerCount: 1});
let computePassEncoder14 = commandEncoder17.beginComputePass({});
try {
computePassEncoder8.setBindGroup(1, bindGroup1, new Uint32Array(10000), 2_509, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle2, renderBundle3]);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: -854.0, g: 7.122, b: -773.2, a: -702.6, });
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer3, 'uint32', 48, 27);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer8, 484, 2_588);
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
let buffer12 = device0.createBuffer({
  label: '\u097b\u5584\u0c74\u0e1b\uc7d2\u2c14\u07b3\uc9ff\u5ed2',
  size: 20023,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
try {
computePassEncoder3.setBindGroup(2, bindGroup3, new Uint32Array(669), 107, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup3, new Uint32Array(822), 306, 0);
} catch {}
let buffer13 = device0.createBuffer({size: 29939, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder18 = device0.createCommandEncoder({});
let texture19 = device0.createTexture({
  size: [26, 20, 92],
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView16 = texture13.createView({label: '\ue0ac\u7625\u{1fc8d}\u{1f980}', mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder15 = commandEncoder18.beginComputePass();
let sampler9 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.09,
  lodMaxClamp: 65.03,
  maxAnisotropy: 9,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder1.setBindGroup(1, bindGroup3, []);
} catch {}
try {
computePassEncoder9.pushDebugGroup('\u2ae2');
} catch {}
let buffer14 = device0.createBuffer({size: 3861, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let textureView17 = texture1.createView({label: '\u{1fb36}\u{1f7bf}\u0bee\u6cc5', mipLevelCount: 1});
try {
computePassEncoder0.setBindGroup(0, bindGroup4, new Uint32Array(2401), 15, 0);
} catch {}
try {
computePassEncoder9.popDebugGroup();
} catch {}
let imageData2 = new ImageData(76, 24);
let texture20 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 156},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView18 = texture17.createView({arrayLayerCount: 1});
try {
computePassEncoder12.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer11, 'uint16', 2_894, 83);
} catch {}
let bindGroup6 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView11}]});
let commandEncoder19 = device0.createCommandEncoder({});
let texture21 = device0.createTexture({
  label: '\u0e8a\u7cbe\ufda6\u{1fc48}\u0dbe\u{1fa3e}\u7d02',
  size: {width: 52, height: 40, depthOrArrayLayers: 51},
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView19 = texture19.createView({label: '\u2317\u282f\u{1f685}\u7663\ucda0\u{1ff41}\ucafe\u96a2', arrayLayerCount: 3});
let computePassEncoder16 = commandEncoder19.beginComputePass({});
let sampler10 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 36.47,
  lodMaxClamp: 91.39,
  maxAnisotropy: 16,
});
try {
renderPassEncoder1.setViewport(0.5840810159350949, 6.735886296302254, 7.37385835816932, 4.691296827114667, 0.15706674478125504, 0.35446121764382177);
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
try {
renderPassEncoder2.executeBundles([renderBundle1, renderBundle0, renderBundle1, renderBundle1, renderBundle3, renderBundle3]);
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer9, 380, buffer3, 8, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 10},
  aspect: 'all',
}, new Uint8Array(1_532).fill(151), /* required buffer size: 1_532 */
{offset: 70, bytesPerRow: 17, rowsPerImage: 43}, {width: 0, height: 0, depthOrArrayLayers: 3});
} catch {}
let canvas0 = document.createElement('canvas');
try {
globalThis.someLabel = renderBundle1.label;
} catch {}
let bindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 112,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 136,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 29,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 124,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let bindGroup7 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 134, resource: externalTexture0}, {binding: 49, resource: textureView1}],
});
let texture22 = device0.createTexture({
  label: '\u7dac\u{1ffc0}\u5576\u7511\u05cd\u7fe3\u2947',
  size: [2, 2, 42],
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder17 = commandEncoder20.beginComputePass({});
try {
computePassEncoder15.setBindGroup(3, bindGroup6, new Uint32Array(944), 27, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(582), 158, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer8, 'uint32', 4_016, 120);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(6, buffer2, 580);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 1364, new BigUint64Array(8973), 34, 176);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext0 = canvas0.getContext('webgpu');
let texture23 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 19},
  format: 'r32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture24 = device0.createTexture({
  size: [55, 8, 312],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(1232), 64, 0);
} catch {}
document.body.prepend(canvas0);
let commandEncoder21 = device0.createCommandEncoder();
let textureView20 = texture23.createView({baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 2});
let textureView21 = texture0.createView({aspect: 'all', baseArrayLayer: 0});
let computePassEncoder18 = commandEncoder21.beginComputePass({});
try {
computePassEncoder18.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer8, 'uint16', 6_356, 485);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer8, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 1, y: 11, z: 3},
  aspect: 'all',
}, new Uint8Array(4_093).fill(207), /* required buffer size: 4_093 */
{offset: 189, bytesPerRow: 61, rowsPerImage: 64}, {width: 9, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas0);
let buffer15 = device0.createBuffer({size: 3643, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder22 = device0.createCommandEncoder({});
let textureView22 = texture23.createView({arrayLayerCount: 1});
let textureView23 = texture4.createView({arrayLayerCount: 1});
let computePassEncoder19 = commandEncoder22.beginComputePass({label: '\ucb60\u0a48\u41f5\u017d\u{1f872}\u8006\u0cbf\u8f3f\u{1f99b}\u05eb'});
let sampler11 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 1.904,
  lodMaxClamp: 57.34,
});
try {
computePassEncoder10.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle0, renderBundle3, renderBundle4, renderBundle2, renderBundle2, renderBundle4]);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer16 = device0.createBuffer({size: 19798, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let textureView24 = texture22.createView({mipLevelCount: 1});
let textureView25 = texture7.createView({});
try {
computePassEncoder1.setBindGroup(2, bindGroup1, new Uint32Array(25), 2, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer6);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 1700, new DataView(new ArrayBuffer(5155)), 51, 968);
} catch {}
try {
  await promise1;
} catch {}
let bindGroup8 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 49, resource: textureView1}, {binding: 134, resource: externalTexture0}],
});
let texture25 = device0.createTexture({
  size: [1290, 8, 125],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder14.setBindGroup(1, bindGroup1, new Uint32Array(8061), 896, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer8, 'uint32', 5_532, 2_275);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
await gc();
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'smpte170m'} });
let buffer17 = device0.createBuffer({
  size: 11541,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder23 = device0.createCommandEncoder({});
let texture26 = device0.createTexture({
  size: [104, 80, 128],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder4.setBindGroup(0, bindGroup3, new Uint32Array(3460), 1_024, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle3, renderBundle0]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer8, 'uint16', 1_610, 220);
} catch {}
try {
commandEncoder23.copyBufferToBuffer(buffer5, 1828, buffer0, 428, 312);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup9 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let commandEncoder24 = device0.createCommandEncoder({});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 1368});
let textureView26 = texture26.createView({aspect: 'all'});
let texture27 = device0.createTexture({
  size: [110, 16, 42],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.executeBundles([renderBundle0, renderBundle4, renderBundle4, renderBundle0, renderBundle1, renderBundle3, renderBundle4, renderBundle1]);
} catch {}
let textureView27 = texture14.createView({arrayLayerCount: 1});
let sampler12 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 15.61,
  lodMaxClamp: 46.25,
  maxAnisotropy: 20,
});
try {
computePassEncoder12.setBindGroup(2, bindGroup7, []);
} catch {}
try {
computePassEncoder16.setBindGroup(3, bindGroup4, new Uint32Array(544), 188, 0);
} catch {}
try {
renderPassEncoder1.setViewport(2.5739056069192454, 22.975718443481476, 5.744055762559174, 13.12003885694757, 0.4450979270068287, 0.6547692586207013);
} catch {}
let commandEncoder25 = device0.createCommandEncoder({});
let texture28 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView28 = texture11.createView({label: '\u0e09\u17c1\u01bd\udb0c\u0e37\u77b8'});
let computePassEncoder20 = commandEncoder23.beginComputePass({});
let renderPassEncoder3 = commandEncoder25.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -323.4, g: -8.768, b: -647.0, a: -134.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup8, new Uint32Array(201), 2, 0);
} catch {}
try {
computePassEncoder8.pushDebugGroup('\uea69');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let sampler13 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 2.121,
  lodMaxClamp: 56.55,
});
try {
computePassEncoder16.setBindGroup(1, bindGroup1, new Uint32Array(1113), 53, 0);
} catch {}
try {
computePassEncoder10.end();
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer3, 8, 4);
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer5, 2124, buffer6, 2052, 824);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture27,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 13},
  aspect: 'all',
}, new Uint8Array(54).fill(215), /* required buffer size: 54 */
{offset: 54}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup10 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let commandEncoder26 = device0.createCommandEncoder({});
let texture29 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder21 = commandEncoder8.beginComputePass({label: '\u0b39\u{1f77d}\u8ab1\u537d\u{1fd60}\u977e'});
let renderPassEncoder4 = commandEncoder26.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -574.5, g: 529.0, b: 958.4, a: 359.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet2,
});
try {
renderPassEncoder4.setIndexBuffer(buffer8, 'uint32', 2_524, 111);
} catch {}
try {
adapter0.label = '\ua6d3\u0166\u020e\u0fba';
} catch {}
let textureView29 = texture21.createView({baseMipLevel: 0, baseArrayLayer: 16, arrayLayerCount: 27});
try {
computePassEncoder18.setBindGroup(0, bindGroup6, new Uint32Array(546), 18, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup7, new Uint32Array(3328), 473, 0);
} catch {}
await gc();
let bindGroup11 = device0.createBindGroup({
  label: '\u7a16\ubc04\u381b\u848d\ucdea\u08ff\u15ac\ud59c\u5ddd\u51e2',
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView17},
    {binding: 285, resource: {buffer: buffer12, offset: 768, size: 7726}},
  ],
});
let buffer18 = device0.createBuffer({
  size: 13429,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder27 = device0.createCommandEncoder({});
let computePassEncoder22 = commandEncoder27.beginComputePass({});
let sampler14 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 18.58,
  lodMaxClamp: 22.63,
  maxAnisotropy: 1,
});
try {
computePassEncoder20.setBindGroup(2, bindGroup5);
} catch {}
try {
computePassEncoder5.setBindGroup(3, bindGroup4, new Uint32Array(697), 44, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup4, new Uint32Array(1116), 62, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer11, 'uint32', 3_004, 229);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer17);
} catch {}
try {
commandEncoder24.copyTextureToBuffer({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2504 */
  offset: 2504,
  bytesPerRow: 13056,
  buffer: buffer1,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer19 = device0.createBuffer({size: 6997, usage: GPUBufferUsage.UNIFORM});
let texture30 = device0.createTexture({
  size: [26, 20, 32],
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder5 = commandEncoder24.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -820.0, g: -994.4, b: 151.6, a: 512.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder4.setVertexBuffer(6, buffer17, 0, 2_189);
} catch {}
let buffer20 = device0.createBuffer({
  size: 15783,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture31 = device0.createTexture({
  size: [52],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg8uint'],
});
let textureView30 = texture11.createView({});
let sampler15 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMaxClamp: 98.37,
  maxAnisotropy: 1,
});
try {
computePassEncoder15.setBindGroup(3, bindGroup11);
} catch {}
let commandEncoder28 = device0.createCommandEncoder();
let texture32 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView31 = texture13.createView({mipLevelCount: 1});
try {
computePassEncoder15.setBindGroup(3, bindGroup5, new Uint32Array(3795), 447, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer20);
} catch {}
try {
commandEncoder28.copyTextureToBuffer({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1978 */
  offset: 1978,
  bytesPerRow: 1280,
  rowsPerImage: 0,
  buffer: buffer1,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 29, resource: textureView26},
    {binding: 7, resource: textureView15},
    {binding: 124, resource: textureView20},
    {binding: 136, resource: textureView24},
    {binding: 112, resource: sampler7},
  ],
});
let renderPassEncoder6 = commandEncoder28.beginRenderPass({
  label: '\u01a1\u4c21\u6368',
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: 125.6, g: 764.4, b: -193.3, a: 702.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder20.setBindGroup(2, bindGroup5, []);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer11, 'uint32', 2_044, 71);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer6, 0, 4_333);
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder29 = device0.createCommandEncoder({});
let computePassEncoder23 = commandEncoder29.beginComputePass({label: '\u048f\u0632\u1848\u6cae\u0b84\ud05d\u40d6\u0012'});
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 15},
  aspect: 'all',
}, new Uint8Array(764).fill(15), /* required buffer size: 764 */
{offset: 71, bytesPerRow: 21, rowsPerImage: 11}, {width: 5, height: 0, depthOrArrayLayers: 4});
} catch {}
let bindGroupLayout5 = device0.createBindGroupLayout({
  label: '\u0547\u1fc3\ueab5\uc764\ub17d\u580e',
  entries: [
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 296,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 107,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 41,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 268,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 115,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 38,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 245,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let commandEncoder30 = device0.createCommandEncoder();
let texture33 = device0.createTexture({
  size: [161, 1, 15],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView32 = texture28.createView({dimension: '2d-array', aspect: 'stencil-only', format: 'stencil8', baseArrayLayer: 0});
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle4]);
} catch {}
try {
commandEncoder24.copyTextureToTexture({
  texture: texture24,
  mipLevel: 1,
  origin: {x: 6, y: 2, z: 6},
  aspect: 'all',
},
{
  texture: texture21,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt470m', transfer: 'hlg'} });
let bindGroup13 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView18}]});
let commandEncoder31 = device0.createCommandEncoder();
let commandBuffer0 = commandEncoder24.finish();
let textureView33 = texture33.createView({format: 'r32uint'});
let textureView34 = texture33.createView({});
let computePassEncoder24 = commandEncoder30.beginComputePass({});
let externalTexture2 = device0.importExternalTexture({label: '\u{1faa9}\u0b69\u0264\u0993\u42ec\u0e78\u0eaa\u068f\u112b\u681f\u05f4', source: videoFrame1});
try {
renderPassEncoder0.setVertexBuffer(6, buffer17, 2_252);
} catch {}
let commandEncoder32 = device0.createCommandEncoder({});
let texture34 = device0.createTexture({
  size: [161, 1, 15],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView35 = texture16.createView({arrayLayerCount: 1});
try {
renderPassEncoder4.setBindGroup(2, bindGroup9, new Uint32Array(1671), 212, 0);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: 982.4, g: 739.5, b: -860.9, a: 748.2, });
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer3, 'uint16', 178, 12);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer17);
} catch {}
let buffer21 = device0.createBuffer({
  size: 26038,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture35 = device0.createTexture({
  size: {width: 1290},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView36 = texture22.createView({baseMipLevel: 0});
let computePassEncoder25 = commandEncoder31.beginComputePass();
try {
renderPassEncoder0.setBindGroup(0, bindGroup9);
} catch {}
let canvas1 = document.createElement('canvas');
let commandEncoder33 = device0.createCommandEncoder({});
let textureView37 = texture35.createView({baseMipLevel: 0});
let renderPassEncoder7 = commandEncoder32.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: 21.59, g: -370.0, b: 105.0, a: -64.12, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder16.setBindGroup(3, bindGroup4, new Uint32Array(76), 0, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer3, 'uint16', 8, 11);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer20, 0);
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt470bg', transfer: 'bt2020_12bit'} });
let videoFrame4 = new VideoFrame(canvas1, {timestamp: 0});
let commandEncoder34 = device0.createCommandEncoder({});
let texture36 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 62},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder8 = commandEncoder33.beginRenderPass({
  label: '\ua51b\u{1fc9c}\u0566\ue251\uafa6\u0e76\u2ae1',
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 35.53, g: -935.7, b: 986.3, a: 6.563, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer3, 'uint32', 48, 120);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer11, 388, 239);
} catch {}
try {
  await buffer0.mapAsync(GPUMapMode.READ, 32, 128);
} catch {}
try {
commandEncoder34.copyBufferToBuffer(buffer9, 1204, buffer6, 1168, 612);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 880 */
  offset: 880,
  buffer: buffer10,
}, {
  texture: texture1,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture37 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 8},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder7.setStencilReference(40);
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer1, offset: 256, size: 3937}},
    {binding: 37, resource: textureView5},
  ],
});
let buffer22 = device0.createBuffer({
  label: '\u16ec\ufda6\u1c2b\ufddf\u1353\u085e\u0a9a\u0ecd\u{1faac}',
  size: 12423,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder35 = device0.createCommandEncoder({label: '\u{1f81f}\u287f\u0dc5\u0263\ub18a\u0bdd\u46fd\ufcf4\u5a1d\u00a7\u5385'});
let texture38 = device0.createTexture({
  size: [55, 8, 312],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let sampler16 = device0.createSampler({
  label: '\u2b1f\u{1f9aa}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 51.24,
  lodMaxClamp: 99.08,
});
try {
renderBundleEncoder5.setBindGroup(2, bindGroup5);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 64, new DataView(new ArrayBuffer(15661)), 858, 260);
} catch {}
let texture39 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 681},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setBindGroup(1, bindGroup3);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer1, 'uint16', 3_916, 1_458);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer15, 268, 38);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup3, []);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 93, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 44, y: 4, z: 42},
  aspect: 'all',
},
{width: 25, height: 2, depthOrArrayLayers: 5});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup15 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let textureView38 = texture39.createView({});
let renderPassEncoder9 = commandEncoder35.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 877.2, g: 754.3, b: 8.138, a: 28.55, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder7.setBindGroup(2, bindGroup9);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup13, new Uint32Array(99), 39, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer3, 'uint32', 16, 10);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup4);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture30,
  mipLevel: 0,
  origin: {x: 1, y: 4, z: 10},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'smpte240m'} });
let commandEncoder36 = device0.createCommandEncoder({});
let texture40 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 32},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView39 = texture31.createView({});
let computePassEncoder26 = commandEncoder34.beginComputePass({});
let renderPassEncoder10 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: 462.0, g: 536.3, b: -145.5, a: 148.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler17 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 13.83,
  lodMaxClamp: 29.50,
  maxAnisotropy: 5,
});
try {
computePassEncoder0.setBindGroup(1, bindGroup12);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup15);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup8, new Uint32Array(922), 0, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer17, 'uint32', 1_628, 4_278);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 996, new Int16Array(4120), 55, 408);
} catch {}
document.body.append(canvas1);
let bindGroup16 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 296, resource: textureView12},
    {binding: 38, resource: textureView38},
    {binding: 245, resource: textureView33},
    {binding: 268, resource: textureView2},
    {binding: 41, resource: {buffer: buffer22, offset: 1280, size: 2396}},
    {binding: 115, resource: textureView37},
    {binding: 9, resource: {buffer: buffer16, offset: 1536, size: 4083}},
    {binding: 107, resource: textureView23},
  ],
});
let buffer23 = device0.createBuffer({size: 2934, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let texture41 = device0.createTexture({
  size: [161, 1, 16],
  mipLevelCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler18 = device0.createSampler({
  label: '\u{1fa6a}\u{1ff17}\u0ed7\u2de2',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 58.12,
  lodMaxClamp: 60.26,
  compare: 'less',
});
try {
renderPassEncoder10.setVertexBuffer(3, buffer20);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup1, new Uint32Array(1004), 90, 0);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(7, buffer6, 9_188, 11_379);
} catch {}
document.body.prepend(canvas0);
let sampler19 = device0.createSampler({
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 14.49,
  lodMaxClamp: 88.91,
});
try {
computePassEncoder15.setBindGroup(2, bindGroup5, []);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(667);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer1, 'uint16', 3_408, 3_525);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup13, new Uint32Array(50), 14, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let textureView40 = texture13.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder6.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup6, new Uint32Array(7), 0, 0);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer3, 'uint32', 24, 194);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer21, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup17 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 7, resource: textureView12},
    {binding: 124, resource: textureView20},
    {binding: 112, resource: sampler18},
    {binding: 136, resource: textureView36},
    {binding: 29, resource: textureView26},
  ],
});
let commandEncoder37 = device0.createCommandEncoder();
let textureView41 = texture25.createView({baseArrayLayer: 0});
let texture42 = device0.createTexture({
  label: '\u{1fe61}\u1b90\u0fc5\ud6fd\u783a\u5339\u0ce4\u0172\u0888\u5c5a\u554c',
  size: [13, 10, 1],
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView42 = texture23.createView({baseArrayLayer: 1, arrayLayerCount: 3});
let computePassEncoder27 = commandEncoder37.beginComputePass({});
try {
computePassEncoder25.setBindGroup(3, bindGroup1, new Uint32Array(3269), 786, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup10);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer3, 'uint32', 16, 77);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 4228, new BigUint64Array(9191), 4198, 856);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 40, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(40).fill(223), /* required buffer size: 40 */
{offset: 40, bytesPerRow: 117}, {width: 43, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup18 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 49, resource: textureView3}, {binding: 134, resource: externalTexture1}],
});
let commandEncoder38 = device0.createCommandEncoder({});
let textureView43 = texture38.createView({});
let texture43 = device0.createTexture({size: [645], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
let textureView44 = texture34.createView({});
let renderBundle5 = renderBundleEncoder5.finish();
try {
computePassEncoder23.setBindGroup(0, bindGroup11, []);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle5, renderBundle5, renderBundle3]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer18, 'uint16', 670, 415);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
let textureView45 = texture21.createView({dimension: '2d', baseArrayLayer: 2});
let computePassEncoder28 = commandEncoder38.beginComputePass({});
try {
computePassEncoder25.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup13, new Uint32Array(1819), 903, 0);
} catch {}
let textureView46 = texture38.createView({});
try {
computePassEncoder16.setBindGroup(2, bindGroup18, new Uint32Array(597), 71, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer3, 36, new BigUint64Array(27271), 309, 4);
} catch {}
let bindGroup19 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView18}]});
let buffer24 = device0.createBuffer({
  size: 23059,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture44 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder8.popDebugGroup();
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let buffer25 = device0.createBuffer({
  size: 2498,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture45 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 23},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let texture46 = gpuCanvasContext0.getCurrentTexture();
let textureView47 = texture1.createView({});
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 73.91,
  lodMaxClamp: 92.19,
  maxAnisotropy: 8,
});
try {
computePassEncoder19.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder2.setBindGroup(3, bindGroup17, new Uint32Array(1883), 1_046, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer8, 'uint32', 5_960, 3_106);
} catch {}
try {
buffer8.unmap();
} catch {}
try {
computePassEncoder17.pushDebugGroup('\ud1d1');
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 50});
let texture47 = device0.createTexture({
  size: [1290],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup5, new Uint32Array(1714), 1_462, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture45,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(8_608).fill(222), /* required buffer size: 8_608 */
{offset: 56, bytesPerRow: 75, rowsPerImage: 57}, {width: 1, height: 1, depthOrArrayLayers: 3});
} catch {}
let textureView48 = texture41.createView({arrayLayerCount: 2});
let sampler21 = device0.createSampler({
  label: '\u{1fff4}\uff1a\u0bca\u025e',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 65.88,
  lodMaxClamp: 88.03,
  maxAnisotropy: 3,
});
try {
computePassEncoder17.setBindGroup(1, bindGroup11);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup15, new Uint32Array(0), 0, 0);
} catch {}
let imageData3 = new ImageData(32, 52);
let texture48 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 31},
  sampleCount: 1,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageBitmap1 = await createImageBitmap(canvas1);
let bindGroup20 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView11}]});
let commandEncoder39 = device0.createCommandEncoder({label: '\u0d76\u6a16\u2f7c\u1d5f\uf8be\u83cc'});
let textureView49 = texture38.createView({});
let externalTexture3 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder26.setBindGroup(2, bindGroup6, new Uint32Array(694), 71, 0);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: -90.61, g: -832.1, b: 19.76, a: 101.6, });
} catch {}
try {
buffer7.unmap();
} catch {}
try {
commandEncoder39.clearBuffer(buffer1, 2756, 264);
} catch {}
try {
commandEncoder39.resolveQuerySet(querySet1, 650, 232, buffer14, 0);
} catch {}
let gpuCanvasContext1 = canvas1.getContext('webgpu');
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout5]});
let computePassEncoder29 = commandEncoder39.beginComputePass();
try {
computePassEncoder20.setBindGroup(1, bindGroup20);
} catch {}
try {
buffer21.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 368, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(48).fill(151), /* required buffer size: 48 */
{offset: 48, bytesPerRow: 404}, {width: 189, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let externalTexture4 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
renderPassEncoder7.setViewport(15.237213653324652, 6.0286877871106626, 24.33010349834302, 7.8422027168236506, 0.17481707589622386, 0.6069201172160043);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder40 = device0.createCommandEncoder({});
let textureView50 = texture45.createView({mipLevelCount: 1, arrayLayerCount: 2});
try {
renderPassEncoder2.setIndexBuffer(buffer8, 'uint16', 7_980, 3_632);
} catch {}
try {
commandEncoder40.copyBufferToBuffer(buffer11, 296, buffer13, 2028, 3800);
} catch {}
try {
commandEncoder40.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3704 */
  offset: 3704,
  bytesPerRow: 2816,
  buffer: buffer2,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 456, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(32).fill(99), /* required buffer size: 32 */
{offset: 32}, {width: 354, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet4 = device0.createQuerySet({type: 'occlusion', count: 926});
let texture49 = device0.createTexture({
  size: [27, 4, 156],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup10, new Uint32Array(1841), 165, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle4, renderBundle5, renderBundle4]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer17, 0);
} catch {}
let shaderModule0 = device0.createShaderModule({
  label: '\uc99d\u0dbb\u27c4\u0935\u26ac\uc697\u{1fe94}\u06e1\u9946',
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer26: vec2u;

@group(0) @binding(38) var st0: texture_storage_3d<rg32float, write>;

@group(0) @binding(41) var<storage, read> buffer27: array<i32, 1>;

@group(0) @binding(107) var tex0: texture_1d<u32>;

@group(0) @binding(115) var tex1: texture_1d<i32>;

@group(0) @binding(245) var st1: texture_storage_3d<r32uint, read>;

@group(0) @binding(268) var tex2: texture_2d_array<u32>;

@group(0) @binding(296) var tex3: texture_2d<u32>;

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

struct VertexOutput0 {
  @location(10) f0: i32,
  @builtin(position) f1: vec4f,
}

@id(37992) override override0: u32;

@id(43865) override override1: i32;

override override2: f16;

@id(34402) override override3: f16;

@id(47928) override override4 = true;

override override5 = true;

var<workgroup> vw0: T0;

var<workgroup> vw1: array<VertexOutput0, 5>;

var<workgroup> vw2: T0;

var<workgroup> vw3: mat2x2h;

var<workgroup> vw4: atomic<i32>;

var<workgroup> vw5: T0;

var<workgroup> vw6: VertexOutput0;

var<workgroup> vw7: mat4x4f;

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

var<workgroup> vw9: atomic<u32>;

var<workgroup> vw10: mat4x2h;

var<workgroup> vw11: mat4x3f;

var<workgroup> vw12: atomic<i32>;

@vertex
fn vertex0(@location(14) @interpolate(flat) a0: vec4i, @location(3) a1: vec4f, @location(7) a2: vec4i, @builtin(instance_index) a3: u32, @location(0) @interpolate(flat, sample) a4: vec4u) -> VertexOutput0 {
  var out: VertexOutput0;
  let vf0: u32 = pack2x16snorm(vec2f(unconst_f32(0.1702), unconst_f32(0.03527)));
  let vf1: f16 = sign(f16(unconst_f16(11586.9)));
  let vf2: vec4f = a1;
  out.f0 += a0[1];
  let ptr0: ptr<storage, array<i32, 1>, read> = &(*&buffer27);
  out.f1 = vec4f(f32(override3));
  let vf3: f32 = a1[pack2x16unorm(atan(vec2f(unconst_f32(0.1239), unconst_f32(0.1006))))];
  var vf4: i32 = override1;
  out.f1 = vec4f(bitcast<f32>((*ptr0)[0]));
  let vf5: u32 = vf0;
  out.f0 &= i32(step(vec3h(unconst_f16(5948.8), unconst_f16(3126.8), unconst_f16(-692.4)), vec3h(unconst_f16(23368.3), unconst_f16(10526.0), unconst_f16(-2532.3)))[1]);
  let vf6: f16 = sign(f16(unconst_f16(1914.3)));
  vf4 = (*ptr0)[0];
  let vf7: vec3h = step(vec3h(unconst_f16(5435.7), unconst_f16(9745.2), unconst_f16(331.3)), vec3h(cross(vec3f(unconst_f32(0.1997), unconst_f32(0.06893), unconst_f32(0.1529)), vec3f(f32((*ptr0)[0])))));
  var vf8: u32 = a4[u32(unconst_u32(128))];
  var vf9: u32 = a4[u32(unconst_u32(73))];
  out.f0 -= override1;
  return out;
  _ = override1;
  _ = override3;
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup21 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 107, resource: textureView28},
    {binding: 268, resource: textureView32},
    {binding: 9, resource: {buffer: buffer19, offset: 1280, size: 186}},
    {binding: 38, resource: textureView46},
    {binding: 41, resource: {buffer: buffer8, offset: 13056, size: 5048}},
    {binding: 245, resource: textureView34},
    {binding: 296, resource: textureView12},
    {binding: 115, resource: textureView37},
  ],
});
let computePassEncoder30 = commandEncoder40.beginComputePass({});
try {
renderPassEncoder4.setScissorRect(7, 10, 3, 2);
} catch {}
let arrayBuffer0 = buffer0.getMappedRange(136, 8);
let bindGroup22 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView14}]});
let commandEncoder41 = device0.createCommandEncoder({});
let computePassEncoder31 = commandEncoder41.beginComputePass({});
try {
renderPassEncoder0.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer9, 'uint16', 688, 202);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder17.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer12, 3412, new BigUint64Array(416), 100, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 1,
  origin: {x: 11, y: 0, z: 8},
  aspect: 'all',
}, new Uint8Array(53_589).fill(106), /* required buffer size: 53_589 */
{offset: 214, bytesPerRow: 25, rowsPerImage: 61}, {width: 2, height: 0, depthOrArrayLayers: 36});
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteSt4281', transfer: 'smpte170m'} });
let buffer28 = device0.createBuffer({
  size: 5526,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder42 = device0.createCommandEncoder({});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 93});
let sampler22 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 53.05,
  lodMaxClamp: 93.34,
  compare: 'greater',
  maxAnisotropy: 6,
});
try {
computePassEncoder25.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder6.setBindGroup(0, bindGroup17, new Uint32Array(1489), 120, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 1968, new Float32Array(13754), 3794, 1344);
} catch {}
let bindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 66,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 81,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 146,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 388,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 384,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 61, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 46,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 114,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 132,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 154,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 140,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 59,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 21,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 217,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 51,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 35,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 134, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 22, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 136,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 19,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 309,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 381,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {
      binding: 161,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 64,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 201,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 29,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 87, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {binding: 525, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 307,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 56, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 104,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true },
    },
    {
      binding: 158,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 413,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {binding: 137, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 45,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {binding: 67, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 98,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 8, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {
      binding: 107,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 177, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 128,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 130,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 84, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 76,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 20,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 133, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {binding: 420, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {
      binding: 280,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {binding: 119, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 193,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {binding: 44, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {binding: 216, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }},
    {
      binding: 191,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 18,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 160,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {binding: 90, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let texture50 = device0.createTexture({
  size: {width: 1, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder8.setBindGroup(1, bindGroup1);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(161);
} catch {}
let arrayBuffer1 = buffer0.getMappedRange(32, 8);
let buffer29 = device0.createBuffer({
  size: 35368,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder43 = device0.createCommandEncoder();
let texture51 = device0.createTexture({size: [110, 16, 12], format: 'r32sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let texture52 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 59},
  dimension: '2d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder31.setBindGroup(2, bindGroup5, []);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup6, new Uint32Array(1435), 429, 0);
} catch {}
try {
renderPassEncoder7.setScissorRect(0, 0, 18, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer11, 'uint16', 58, 217);
} catch {}
try {
commandEncoder43.copyBufferToBuffer(buffer4, 536, buffer12, 160, 4);
} catch {}
try {
commandEncoder43.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5310 */
  offset: 5302,
  rowsPerImage: 30,
  buffer: buffer18,
}, {
  texture: texture45,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 7},
  aspect: 'all',
}, {width: 4, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder42.copyTextureToBuffer({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 20 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1310 */
  offset: 1310,
  buffer: buffer13,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\ucf8e\u{1f728}\ua2d7\ucf20\uf997\u011b\ucc5f\ub0f2\u{1fbd8}';
} catch {}
let buffer30 = device0.createBuffer({
  size: 4190,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder44 = device0.createCommandEncoder();
let textureView51 = texture46.createView({label: '\u1254\u{1ffc1}\u{1fab5}\uf2bb\u04f3\u0628', mipLevelCount: 1});
try {
renderPassEncoder3.setBindGroup(1, bindGroup22, new Uint32Array(4908), 516, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer28, 0);
} catch {}
try {
buffer15.unmap();
} catch {}
try {
globalThis.someLabel = computePassEncoder28.label;
} catch {}
let commandEncoder45 = device0.createCommandEncoder({});
let textureView52 = texture51.createView({label: '\ufc32\u0985\uea3a\u0eaa\u8587', arrayLayerCount: 2});
let texture53 = device0.createTexture({
  label: '\u3234\u{1f6a3}\u1cfc\u0b49\u738f\u0d64\u814b\u1e6b\uf5f1\uc6ca\u{1ff94}',
  size: [52],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView53 = texture30.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder32 = commandEncoder42.beginComputePass({});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1});
let externalTexture5 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder23.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle4, renderBundle4]);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup19);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder45.clearBuffer(buffer13, 1100, 3896);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let texture54 = device0.createTexture({
  label: '\u{1f6bb}\u7dd4\u31bf\u024e\u080f',
  size: [26, 20, 22],
  mipLevelCount: 1,
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView54 = texture16.createView({});
try {
computePassEncoder24.setBindGroup(3, bindGroup10, new Uint32Array(467), 163, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle1]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer30, 1_296, 1_066);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(5, buffer20, 0, 1_520);
} catch {}
try {
commandEncoder44.copyBufferToBuffer(buffer11, 2812, buffer14, 128, 628);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: imageData2,
  origin: { x: 11, y: 9 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 4, y: 1, z: 47},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 162,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let buffer31 = device0.createBuffer({
  label: '\u09af\uc74e\u{1ff4d}\u92fa\ud76f\u{1fb7a}\u{1ff9e}\u99fe\u3b8d\uadc4',
  size: 6933,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder46 = device0.createCommandEncoder({});
let texture55 = device0.createTexture({
  size: {width: 2094, height: 18, depthOrArrayLayers: 10},
  mipLevelCount: 3,
  format: 'astc-6x6-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder33 = commandEncoder45.beginComputePass({});
try {
computePassEncoder5.setBindGroup(2, bindGroup0);
} catch {}
try {
computePassEncoder9.setBindGroup(2, bindGroup19, new Uint32Array(13), 0, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup4);
} catch {}
try {
buffer31.unmap();
} catch {}
try {
commandEncoder44.copyBufferToTexture({
  /* bytesInLastRow: 68 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1036 */
  offset: 1036,
  bytesPerRow: 12800,
  buffer: buffer18,
}, {
  texture: texture33,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 2},
  aspect: 'all',
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: videoFrame4,
  origin: { x: 21, y: 10 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer32 = device0.createBuffer({
  label: '\u7998\ufcfb\u03d9\ufdc2\u2053\u7dd3\u08c6',
  size: 30307,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView55 = texture54.createView({label: '\u3234\u48ef\u0c01\u0ee5\u0b86\u0653\uc940\u5776\ucf16', dimension: '2d', baseArrayLayer: 2});
let texture56 = device0.createTexture({size: [13, 2, 69], format: 'rg16uint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
let textureView56 = texture7.createView({});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
try {
computePassEncoder14.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder20.setBindGroup(3, bindGroup17, new Uint32Array(466), 65, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup11);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup1, new Uint32Array(676), 5, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup22);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer9, 'uint16', 8, 1_386);
} catch {}
try {
commandEncoder46.copyTextureToTexture({
  texture: texture18,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder46.resolveQuerySet(querySet1, 1149, 183, buffer31, 0);
} catch {}
try {
  await promise5;
} catch {}
let imageBitmap2 = await createImageBitmap(imageData2);
let texture57 = device0.createTexture({
  size: [104, 80, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder34 = commandEncoder46.beginComputePass({label: '\u0a8f\u55ca'});
try {
computePassEncoder23.setBindGroup(2, bindGroup1, new Uint32Array(2408), 96, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup3);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer24, 'uint16', 904, 2_514);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(1, buffer6, 1_040, 10_093);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: imageData0,
  origin: { x: 0, y: 13 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 75},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData4 = new ImageData(24, 20);
let buffer33 = device0.createBuffer({
  label: '\ufcc8\u4835\u092f\u83a3\u0202\u{1f7cb}',
  size: 13183,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder47 = device0.createCommandEncoder();
let texture58 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView57 = texture40.createView({format: 'rg8uint'});
let computePassEncoder35 = commandEncoder44.beginComputePass();
let sampler23 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.64,
});
try {
computePassEncoder15.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup19);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup5, new Uint32Array(93), 0, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
adapter0.label = '\u2151\ua8f2\u{1ff12}\u0a37\u4218\u08d9\uaa40';
} catch {}
let textureView58 = texture50.createView({mipLevelCount: 1});
try {
renderPassEncoder3.setIndexBuffer(buffer25, 'uint16', 2_498, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(4, buffer2, 1_216);
} catch {}
let texture59 = device0.createTexture({
  label: '\uc9bb\u0892\ub4de\u446f\ue212\u2993\u9e46\u8f21',
  size: [13, 2, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture60 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder36 = commandEncoder43.beginComputePass();
let renderBundle6 = renderBundleEncoder6.finish();
try {
commandEncoder47.insertDebugMarker('\ua355');
} catch {}
try {
computePassEncoder6.insertDebugMarker('\u70dd');
} catch {}
try {
device0.queue.writeBuffer(buffer1, 5788, new Int16Array(17413), 4250, 788);
} catch {}
let imageData5 = new ImageData(24, 52);
let buffer34 = device0.createBuffer({
  size: 23020,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture61 = device0.createTexture({
  label: '\u540c\u0c24\u3347\u929f',
  size: [52, 40, 1],
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView59 = texture39.createView({aspect: 'all', mipLevelCount: 1});
let computePassEncoder37 = commandEncoder47.beginComputePass();
let sampler24 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 91.06,
  lodMaxClamp: 91.26,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup20);
} catch {}
try {
computePassEncoder18.setBindGroup(3, bindGroup16, new Uint32Array(2923), 261, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup19, new Uint32Array(19), 3, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer31, 'uint16', 2_936, 561);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer30, 232);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup4);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup6, new Uint32Array(698), 698, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 55, height: 8, depthOrArrayLayers: 312}
*/
{
  source: imageData1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 6},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let buffer35 = device0.createBuffer({
  size: 3716,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder48 = device0.createCommandEncoder({});
let textureView60 = texture54.createView({baseArrayLayer: 1, arrayLayerCount: 4});
let texture62 = device0.createTexture({
  size: [2, 2, 27],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView61 = texture60.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 2});
try {
renderPassEncoder9.setVertexBuffer(0, buffer8, 0);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
await gc();
let textureView62 = texture46.createView({label: '\ubb3c\u0f4d\u00a7'});
let texture63 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 52},
  mipLevelCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder38 = commandEncoder48.beginComputePass({});
let renderBundle7 = renderBundleEncoder7.finish({label: '\u{1f8e7}\ua301\u605f\u{1f8a8}'});
try {
renderPassEncoder4.setVertexBuffer(6, buffer15, 0, 442);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame7 = new VideoFrame(videoFrame6, {timestamp: 0});
let commandEncoder49 = device0.createCommandEncoder({});
let texture64 = device0.createTexture({
  label: '\u0f52\u{1f741}',
  size: [4, 4, 1],
  sampleCount: 4,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder9.setBindGroup(2, bindGroup1, new Uint32Array(919), 5, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer8, 'uint16', 64, 4_416);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
commandEncoder49.copyBufferToBuffer(buffer2, 6688, buffer9, 164, 156);
} catch {}
try {
device0.queue.writeBuffer(buffer30, 308, new Int16Array(4780), 2008, 236);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let texture65 = device0.createTexture({
  size: [110, 16, 50],
  mipLevelCount: 2,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture66 = device0.createTexture({
  size: [645, 4, 1],
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView63 = texture0.createView({format: 'bgra8unorm'});
let computePassEncoder39 = commandEncoder49.beginComputePass({});
let externalTexture6 = device0.importExternalTexture({source: videoFrame3});
try {
renderPassEncoder4.setVertexBuffer(4, buffer21);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas1);
let textureView64 = texture64.createView({});
let textureView65 = texture59.createView({label: '\u08a8\uc2a5\u0b89\u0c8c', baseMipLevel: 0});
try {
renderPassEncoder7.executeBundles([renderBundle2, renderBundle4, renderBundle6, renderBundle3]);
} catch {}
try {
buffer14.unmap();
} catch {}
document.body.append(canvas1);
await gc();
let bindGroup23 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView5},
    {binding: 285, resource: {buffer: buffer19, offset: 256, size: 5216}},
  ],
});
let commandEncoder50 = device0.createCommandEncoder({});
let textureView66 = texture59.createView({
  label: '\uc67a\ud851\u0d64\ud841\u0a7f\u2d59\ua033',
  dimension: '2d-array',
  aspect: 'all',
  format: 'rg32uint',
});
let externalTexture7 = device0.importExternalTexture({source: videoFrame3});
let bindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 31,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
  ],
});
let textureView67 = texture32.createView({
  label: '\uc911\u5970\udbdd\u{1ff89}\u{1ff79}\ufe56',
  dimension: 'cube-array',
  baseArrayLayer: 2,
  arrayLayerCount: 6,
});
let textureView68 = texture61.createView({
  label: '\u{1fefd}\u012a\ub341\u0577\u055d\u89e4\ua4ed\u{1f9fe}\u0c96\ub780\u{1f940}',
  dimension: '2d-array',
  mipLevelCount: 1,
});
let externalTexture8 = device0.importExternalTexture({label: '\u{1faaf}\u{1ff76}\u6f71\ue0cb', source: videoFrame3, colorSpace: 'srgb'});
try {
renderPassEncoder1.executeBundles([renderBundle5, renderBundle6, renderBundle6]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer18, 'uint32', 4_012, 2_361);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder51 = device0.createCommandEncoder({});
let texture67 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 49},
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture68 = device0.createTexture({
  size: [13, 10, 57],
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView69 = texture1.createView({});
try {
computePassEncoder33.setBindGroup(0, bindGroup18);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup6, new Uint32Array(342), 147, 0);
} catch {}
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte170m', transfer: 'bt2020_10bit'} });
let bindGroup24 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 124, resource: textureView20},
    {binding: 7, resource: textureView15},
    {binding: 112, resource: sampler18},
    {binding: 136, resource: textureView36},
    {binding: 29, resource: textureView26},
  ],
});
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 439});
let texture69 = device0.createTexture({
  size: [13, 2, 30],
  sampleCount: 1,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView70 = texture43.createView({});
try {
renderPassEncoder7.setBindGroup(3, bindGroup4, new Uint32Array(18), 2, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer11, 'uint16', 210, 676);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(3, undefined);
} catch {}
try {
commandEncoder51.copyBufferToBuffer(buffer5, 296, buffer1, 844, 5712);
} catch {}
try {
commandEncoder51.copyTextureToBuffer({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 61, y: 0, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 188 widthInBlocks: 47 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1056 */
  offset: 1056,
  buffer: buffer30,
}, {width: 47, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder51.resolveQuerySet(querySet2, 202, 158, buffer32, 4608);
} catch {}
let bindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 134,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 156,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 495,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 66,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 108,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 72,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 25,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 319, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 189,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 207,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 268,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let buffer36 = device0.createBuffer({
  size: 24633,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let textureView71 = texture48.createView({});
try {
  await promise3;
} catch {}
let bindGroup25 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler21}, {binding: 28, resource: textureView10}],
});
let commandEncoder52 = device0.createCommandEncoder({});
let texture70 = device0.createTexture({
  size: [26],
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler25 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 37.48,
  lodMaxClamp: 77.29,
  maxAnisotropy: 14,
});
try {
renderPassEncoder7.setVertexBuffer(7, buffer2, 0);
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'smpte240m'} });
let commandEncoder53 = device0.createCommandEncoder();
let texture71 = device0.createTexture({
  size: [52, 40, 1],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder4.setBindGroup(1, bindGroup17, new Uint32Array(451), 39, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup15);
} catch {}
let bindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 348,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 162,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 55,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 141,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 209,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 125,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 195,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 33,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 318,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 161,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 67,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 142,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 479, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 5,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 61,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '1d' },
    },
    {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 95,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {binding: 47, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 408,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 712,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 118,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 697,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 328,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 112,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 228,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 232,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 36, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 62, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {
      binding: 34,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 54, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 216, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 38,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 99,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 330,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 135, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 384, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 29, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {
      binding: 20,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', minBindingSize: 626, hasDynamicOffset: false },
    },
  ],
});
let bindGroup26 = device0.createBindGroup({
  label: '\u0cba\ua9f2\u01f3\u0361\u{1fc49}\u0a8d\u7373\u0b4d\u0043\u2848\u{1f8c7}',
  layout: bindGroupLayout1,
  entries: [],
});
let buffer37 = device0.createBuffer({
  label: '\u5837\u0fd9\u5987\u0348\u0f57\u05e5\u6491\u180e\u18da\u84ee',
  size: 17252,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView72 = texture70.createView({});
let texture72 = device0.createTexture({
  label: '\u887c\u0420\u698c',
  size: {width: 52},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView73 = texture11.createView({});
let sampler26 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 64.68,
  lodMaxClamp: 67.87,
  maxAnisotropy: 13,
});
try {
computePassEncoder24.setBindGroup(2, bindGroup14);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
let arrayBuffer2 = buffer0.getMappedRange(40, 8);
try {
device0.queue.writeTexture({
  texture: texture70,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(173).fill(144), /* required buffer size: 173 */
{offset: 173, rowsPerImage: 3}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 148,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 389,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
  ],
});
let bindGroup27 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 296, resource: textureView15},
    {binding: 268, resource: textureView2},
    {binding: 41, resource: {buffer: buffer22, offset: 1024, size: 288}},
    {binding: 245, resource: textureView33},
    {binding: 38, resource: textureView38},
    {binding: 9, resource: {buffer: buffer16, offset: 1280, size: 1428}},
    {binding: 115, resource: textureView37},
    {binding: 107, resource: textureView73},
  ],
});
let texture73 = device0.createTexture({
  size: [110, 16, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture74 = device0.createTexture({
  size: {width: 13},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder40 = commandEncoder52.beginComputePass({});
let sampler27 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 24.05,
  lodMaxClamp: 70.82,
});
let externalTexture9 = device0.importExternalTexture({source: videoFrame8});
try {
commandEncoder50.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1690 */
  offset: 1690,
  buffer: buffer33,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let texture75 = device0.createTexture({
  size: {width: 55},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture76 = device0.createTexture({
  label: '\u619f\u2139\u97ce\u{1f608}\u{1f71e}\u3c52\u24c0\u905d\u0f30\u833f\u{1f745}',
  size: [13],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture10 = device0.importExternalTexture({label: '\u70f7\u45ae\u21b4\ua6bf\u0c3c\u{1fc47}\u{1fe0d}', source: videoFrame6});
try {
computePassEncoder18.setBindGroup(0, bindGroup10, new Uint32Array(819), 28, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup17);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer24, 'uint16', 10_596, 1_074);
} catch {}
try {
commandEncoder28.copyBufferToTexture({
  /* bytesInLastRow: 224 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2512 */
  offset: 2512,
  buffer: buffer32,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 34, y: 0, z: 4},
  aspect: 'all',
}, {width: 14, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroup28 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 29, resource: textureView26},
    {binding: 136, resource: textureView24},
    {binding: 124, resource: textureView20},
    {binding: 112, resource: sampler7},
    {binding: 7, resource: textureView15},
  ],
});
let textureView74 = texture75.createView({dimension: '1d', format: 'rgba8uint', mipLevelCount: 1});
let texture77 = device0.createTexture({size: [13], dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder41 = commandEncoder51.beginComputePass({});
try {
computePassEncoder24.setBindGroup(0, bindGroup0, new Uint32Array(415), 37, 0);
} catch {}
try {
commandEncoder53.copyBufferToBuffer(buffer37, 1288, buffer18, 252, 3124);
} catch {}
try {
commandEncoder50.insertDebugMarker('\u6142');
} catch {}
try {
device0.queue.writeBuffer(buffer28, 1844, new BigUint64Array(23794), 7334, 132);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 55, height: 8, depthOrArrayLayers: 312}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 62},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let videoFrame10 = videoFrame0.clone();
let texture78 = device0.createTexture({
  size: [26, 20, 1],
  sampleCount: 1,
  dimension: '2d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder42 = commandEncoder50.beginComputePass();
try {
renderPassEncoder7.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup23, new Uint32Array(138), 24, 0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle6, renderBundle3, renderBundle6, renderBundle3, renderBundle1]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer11, 'uint32', 672, 96);
} catch {}
try {
commandEncoder53.resolveQuerySet(querySet0, 65, 52, buffer35, 256);
} catch {}
let buffer38 = device0.createBuffer({size: 1218, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder54 = device0.createCommandEncoder({});
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 195});
let texture79 = device0.createTexture({
  size: [27, 4, 54],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler28 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 5.315,
  lodMaxClamp: 81.15,
});
try {
computePassEncoder13.setBindGroup(0, bindGroup3, new Uint32Array(3512), 1_275, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup9);
} catch {}
let bindGroup29 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let commandEncoder55 = device0.createCommandEncoder();
let texture80 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 85},
  mipLevelCount: 2,
  format: 'etc2-rgb8a1unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder11 = commandEncoder53.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -370.3, g: 36.02, b: 755.7, a: -907.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder3.setBindGroup(2, bindGroup26);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle6]);
} catch {}
try {
buffer8.unmap();
} catch {}
try {
commandEncoder55.resolveQuerySet(querySet6, 3, 139, buffer23, 768);
} catch {}
let bindGroup30 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 7, resource: textureView65},
    {binding: 124, resource: textureView22},
    {binding: 29, resource: textureView26},
    {binding: 136, resource: textureView36},
    {binding: 112, resource: sampler22},
  ],
});
let buffer39 = device0.createBuffer({size: 19904, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let textureView75 = texture62.createView({label: '\u7fbd\u26b4\u06c1\u099b\u8958\u979d\u726b', dimension: 'cube', baseArrayLayer: 2});
let texture81 = device0.createTexture({
  size: [13, 2, 1],
  sampleCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture82 = gpuCanvasContext0.getCurrentTexture();
let textureView76 = texture81.createView({});
try {
renderPassEncoder3.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer22, 0, 866);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer36, 6208, new Float32Array(5473), 1139, 172);
} catch {}
let bindGroupLayout12 = device0.createBindGroupLayout({
  label: '\u30b0\u{1fe29}\u{1fdfc}\ud2bc\u1bba\u026e\ubbc7\u0a70',
  entries: [
    {
      binding: 293,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let commandEncoder56 = device0.createCommandEncoder();
let texture83 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder15.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
renderPassEncoder8.setViewport(8.554692985729519, 35.71549379467545, 18.903889821236493, 2.17316459800241, 0.425658092250742, 0.9995405008242155);
} catch {}
let bindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 119,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 220,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 289,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 230,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 74,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 206,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 380,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {binding: 196, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
  ],
});
let commandEncoder57 = device0.createCommandEncoder({});
let textureView77 = texture60.createView({
  label: '\u85fc\u123b\ud46a\u{1fc5e}\u{1f6e2}',
  dimension: 'cube-array',
  baseMipLevel: 0,
  baseArrayLayer: 6,
  arrayLayerCount: 6,
});
let computePassEncoder43 = commandEncoder28.beginComputePass({});
let textureView78 = texture70.createView({aspect: 'all'});
let computePassEncoder44 = commandEncoder54.beginComputePass({});
try {
computePassEncoder44.setBindGroup(3, bindGroup7, new Uint32Array(3583), 1_294, 0);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer24, 0, 1_558);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder56.copyBufferToBuffer(buffer3, 136, buffer1, 3252, 44);
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 110 widthInBlocks: 55 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4210 */
  offset: 4210,
  buffer: buffer11,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 220, y: 0, z: 0},
  aspect: 'all',
}, {width: 55, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder9.copyTextureToTexture({
  texture: texture73,
  mipLevel: 0,
  origin: {x: 18, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture67,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
},
{width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas1);
let buffer40 = device0.createBuffer({
  label: '\ud96c\u{1fe88}\u5031\u81d7\u352d',
  size: 6134,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture84 = device0.createTexture({
  size: [1290, 8, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView79 = texture4.createView({});
try {
renderPassEncoder7.executeBundles([renderBundle1]);
} catch {}
try {
commandEncoder55.copyBufferToBuffer(buffer38, 168, buffer6, 2424, 48);
} catch {}
try {
commandEncoder55.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1530 */
  offset: 1530,
  bytesPerRow: 22272,
  rowsPerImage: 2033,
  buffer: buffer17,
}, {
  texture: texture57,
  mipLevel: 0,
  origin: {x: 15, y: 1, z: 0},
  aspect: 'all',
}, {width: 12, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder57.copyTextureToBuffer({
  texture: texture55,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 6},
  aspect: 'all',
}, {
  /* bytesInLastRow: 5248 widthInBlocks: 328 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 7008 */
  offset: 7008,
  buffer: buffer13,
}, {width: 1968, height: 0, depthOrArrayLayers: 1});
} catch {}
let texture85 = device0.createTexture({
  size: [110, 16, 1],
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture86 = device0.createTexture({
  label: '\ue7aa\ue8a0\u5cef\u6905\ub746\ubc8d\u0b54',
  size: [26],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder45 = commandEncoder55.beginComputePass({});
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle3, renderBundle6, renderBundle7]);
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 726 */
  offset: 722,
  buffer: buffer36,
}, {
  texture: texture30,
  mipLevel: 0,
  origin: {x: 2, y: 18, z: 1},
  aspect: 'all',
}, {width: 2, height: 1, depthOrArrayLayers: 1});
} catch {}
let texture87 = device0.createTexture({
  label: '\u8ea1\udd47\ua323\uf32c',
  size: {width: 322, height: 2, depthOrArrayLayers: 16},
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView80 = texture63.createView({format: 'rgba16uint', baseArrayLayer: 2, arrayLayerCount: 1});
let computePassEncoder46 = commandEncoder56.beginComputePass({label: '\ub644\u{1fce7}\udb85\u038b\u1b0b'});
let renderPassEncoder12 = commandEncoder9.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: -58.69, g: 481.2, b: 172.1, a: 323.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder3.beginOcclusionQuery(135);
} catch {}
try {
renderPassEncoder7.setViewport(8.821263261561251, 15.921487401063414, 17.76390712361248, 8.795230019412758, 0.3175429861698391, 0.7989308671407355);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer25, 464);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: imageData1,
  origin: { x: 2, y: 21 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 10},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
let texture88 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView81 = texture60.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 0, arrayLayerCount: 2});
let computePassEncoder47 = commandEncoder58.beginComputePass();
try {
computePassEncoder44.setBindGroup(0, bindGroup3);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let pipelineLayout7 = device0.createPipelineLayout({label: '\ueda2\u0757\ufdd5\u7677\u0214\uc49c\ub4ea', bindGroupLayouts: []});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 2964});
let textureView82 = texture79.createView({dimension: '2d-array', baseArrayLayer: 9, arrayLayerCount: 15});
let texture89 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 15},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView83 = texture81.createView({label: '\u10d7\u01d9\u0bc3\u53f8', dimension: '2d-array'});
let computePassEncoder48 = commandEncoder57.beginComputePass({});
try {
computePassEncoder30.setBindGroup(2, bindGroup25, new Uint32Array(322), 186, 0);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer17, 'uint16', 350, 590);
} catch {}
let arrayBuffer3 = buffer0.getMappedRange(48, 12);
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let buffer41 = device0.createBuffer({size: 5, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder59 = device0.createCommandEncoder();
let texture90 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 34},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder11.setBindGroup(3, bindGroup1, new Uint32Array(1627), 273, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer25, 'uint32', 24, 382);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer31, 0);
} catch {}
try {
  await promise7;
} catch {}
let commandBuffer1 = commandEncoder59.finish();
let texture91 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView84 = texture38.createView({});
let sampler29 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 12.79,
});
let externalTexture11 = device0.importExternalTexture({
  label: '\u{1f9f5}\ubdce\uf422\u0cd5\u2baf\u{1ff99}\ufca0\u018d\uf7b2\u10d0\u8751',
  source: videoFrame7,
  colorSpace: 'display-p3',
});
try {
renderPassEncoder2.setIndexBuffer(buffer25, 'uint32', 972, 813);
} catch {}
let bindGroup31 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 389, resource: textureView55}, {binding: 148, resource: textureView62}],
});
let buffer42 = device0.createBuffer({
  size: 3868,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder60 = device0.createCommandEncoder();
let texture92 = device0.createTexture({
  size: [13, 10, 16],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture93 = device0.createTexture({
  label: '\u0434\uce12\u08a6\u495d',
  size: {width: 13, height: 2, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView85 = texture70.createView({});
try {
renderPassEncoder2.insertDebugMarker('\ucc9a');
} catch {}
let bindGroup32 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 112, resource: sampler22},
    {binding: 7, resource: textureView15},
    {binding: 136, resource: textureView24},
    {binding: 124, resource: textureView42},
    {binding: 29, resource: textureView41},
  ],
});
let buffer43 = device0.createBuffer({
  label: '\uc989\u{1f8d8}\u{1fcb3}\ufe3e',
  size: 1277,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder61 = device0.createCommandEncoder({});
let texture94 = device0.createTexture({
  label: '\u4a40\u0e93\u{1f871}\u0966',
  size: [645, 4, 2],
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture95 = device0.createTexture({
  size: [645, 4, 62],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder49 = commandEncoder60.beginComputePass({});
try {
computePassEncoder44.setBindGroup(2, bindGroup4);
} catch {}
try {
computePassEncoder3.setBindGroup(1, bindGroup18, new Uint32Array(142), 1, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup30, new Uint32Array(519), 20, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle3]);
} catch {}
try {
commandEncoder61.copyBufferToTexture({
  /* bytesInLastRow: 344 widthInBlocks: 172 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1804 */
  offset: 1804,
  buffer: buffer12,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, {width: 172, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder61.copyTextureToTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let bindGroup33 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 7, resource: textureView10},
    {binding: 124, resource: textureView22},
    {binding: 112, resource: sampler18},
    {binding: 136, resource: textureView36},
    {binding: 29, resource: textureView26},
  ],
});
let buffer44 = device0.createBuffer({size: 16959, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let texture96 = device0.createTexture({
  size: [161, 1, 65],
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
commandEncoder61.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 552 */
  offset: 552,
  buffer: buffer2,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(7_587).fill(234), /* required buffer size: 7_587 */
{offset: 27, bytesPerRow: 35, rowsPerImage: 27}, {width: 2, height: 0, depthOrArrayLayers: 9});
} catch {}
let textureView86 = texture73.createView({label: '\u1505\u{1fde1}\u0b35\u6549\u4f7f\u8db7', baseMipLevel: 0});
let computePassEncoder50 = commandEncoder61.beginComputePass({});
try {
device0.queue.writeBuffer(buffer13, 2208, new BigUint64Array(9914), 1056, 852);
} catch {}
try {
  await promise8;
} catch {}
try {
globalThis.someLabel = computePassEncoder46.label;
} catch {}
let commandEncoder62 = device0.createCommandEncoder({});
let textureView87 = texture91.createView({dimension: '2d'});
let computePassEncoder51 = commandEncoder62.beginComputePass({label: '\u{1ff17}\u09d8\ufa39'});
let sampler30 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 12.22,
  lodMaxClamp: 92.80,
});
try {
computePassEncoder7.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup6, new Uint32Array(641), 111, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer45: vec2f;

@group(0) @binding(38) var st2: texture_storage_3d<rg32float, write>;

@group(0) @binding(41) var<storage, read> buffer46: f32;

@group(0) @binding(107) var tex4: texture_1d<u32>;

@group(0) @binding(115) var tex5: texture_1d<i32>;

@group(0) @binding(245) var st3: texture_storage_3d<r32uint, read>;

@group(0) @binding(268) var tex6: texture_2d_array<u32>;

@group(0) @binding(296) var tex7: texture_2d<u32>;

struct T0 {
  @size(176) f0: array<array<vec2i, 18>, 1>,
}

struct T1 {
  f0: vec4h,
}

struct S0 {
  @location(13) f0: vec2u,
  @location(9) f1: f16,
  @location(14) @interpolate(flat, center) f2: vec4u,
}

struct S1 {
  @location(7) @interpolate(flat, sample) f0: f32,
  @location(2) f1: f16,
}

struct VertexOutput1 {
  @builtin(position) f2: vec4f,
  @location(10) @interpolate(flat, centroid) f3: vec2f,
}

struct VertexOutput2 {
  @location(5) f4: vec2i,
  @location(15) f5: vec2i,
  @location(3) f6: f32,
  @builtin(position) f7: vec4f,
  @location(14) @interpolate(flat, center) f8: u32,
  @location(7) @interpolate(flat, sample) f9: vec4u,
}

alias vec3b = vec3<bool>;

override override6: u32 = 70;

override override7: u32 = 39;

@id(3916) override override8: i32;

fn fn0() -> array<vec2i, 1> {
  var out: array<vec2i, 1>;
  var vf10: u32 = vp0.f2[u32(unconst_u32(22))];
  let vf11: u32 = textureNumLevels(tex5);
  let ptr1: ptr<uniform, vec2f> = &(*&buffer45);
  let vf12: vec2u = textureDimensions(tex6, i32(unconst_i32(236)));
  var vf13: vec2u = textureDimensions(tex6);
  vp0.f2 = unpack4xU8(textureNumLevels(tex4));
  return out;
}

var<workgroup> vw13: mat3x4f;

var<workgroup> vw14: vec2f;

var<workgroup> vw15: VertexOutput1;

var<workgroup> vw16: atomic<u32>;

var<private> vp0: S0 = S0();

@vertex
fn vertex1(@location(3) a0: vec2i, @location(12) @interpolate(perspective, centroid) a1: f32, a2: S0, @builtin(instance_index) a3: u32, @location(0) a4: vec2h, a5: S1) -> VertexOutput1 {
  var out: VertexOutput1;
  out.f3 += bitcast<vec2f>(a2.f0);
  let ptr2: ptr<storage, f32, read> = &buffer46;
  var vf14: vec2u = a2.f0;
  vf14 |= vec2u(bitcast<u32>(buffer46));
  let vf15: vec2u = a2.f0;
  return out;
}

@vertex
fn vertex2(@location(7) @interpolate(perspective) a0: vec2f) -> VertexOutput2 {
  var out: VertexOutput2;
  let ptr3: ptr<private, f16> = &vp0.f1;
  var vf16: vec4f = sin(vec4f(unconst_f32(0.1108), unconst_f32(0.2714), unconst_f32(0.02967), unconst_f32(0.3476)));
  out.f6 = f32(override7);
  vf16 = vec4f(bitcast<f32>(override7));
  out.f5 = vec2i(i32(max(f32(unconst_f32(0.06863)), f32(unconst_f32(0.2364)))));
  vf16 = bitcast<vec4f>(vp0.f2);
  out.f9 >>= vec4u(u32((*&buffer46)));
  var vf17: vec3h = fract(vec3h(unconst_f16(21493.7), unconst_f16(-19469.2), unconst_f16(10682.2)));
  return out;
  _ = override7;
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, @location(7) a1: vec4u) -> @location(200) @interpolate(flat, sample) vec4u {
  var out: vec4u;
  var vf18 = fn0();
  out &= vec4u(mix(vec3h(unconst_f16(6089.9), unconst_f16(27427.7), unconst_f16(5848.8)), vec3h(f16(override6)), vec3h(unconst_f16(-9232.2), unconst_f16(1193.9), unconst_f16(3301.5))).xyzz);
  let ptr4: ptr<private, vec2u> = &vp0.f0;
  textureStore(st2, vec3i(unconst_i32(56), unconst_i32(199), unconst_i32(331)), vec4f(vec4f(unconst_f32(0.3895), unconst_f32(0.1554), unconst_f32(0.00566), unconst_f32(0.03568))));
  return out;
  _ = override6;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
  atomicCompareExchangeWeak(&vw16, unconst_u32(63), unconst_u32(117));
  textureStore(st2, vec3i((*&vw15).f2.wzz), vec4f(vec4f(unconst_f32(0.00869), unconst_f32(0.05804), unconst_f32(0.3055), unconst_f32(0.2304))));
  let ptr5: ptr<private, vec4u> = &vp0.f2;
  vw13 -= mat3x4f(bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), f32(textureNumLevels(tex6)), f32(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)), bitcast<f32>(textureNumLevels(tex6)));
  atomicAnd(&vw16, u32(unconst_u32(142)));
  textureStore(st2, vec3i(unconst_i32(4), unconst_i32(161), unconst_i32(73)), vec4f(unpack4x8snorm(vp0.f2[u32(unconst_u32(704))])));
  vw15.f2 += vw15.f2;
  let vf19: u32 = atomicLoad(&vw16);
  atomicCompareExchangeWeak(&vw16, unconst_u32(107), unconst_u32(279));
  let ptr6: ptr<private, S0> = &vp0;
  vw15.f2 += workgroupUniformLoad(&vw14).yxyy;
  atomicAnd(&vw16, u32(unconst_u32(83)));
  let ptr7: ptr<workgroup, vec2f> = &(*&vw14);
  let ptr8: ptr<storage, f32, read> = &(*&buffer46);
  vw13 -= mat3x4f(bitcast<vec4f>((*ptr6).f0.yxxy), bitcast<vec4f>((*ptr6).f0.rrgg), bitcast<vec4f>((*ptr6).f0.yyxy));
  vp0.f1 = f16(buffer45[u32(unconst_u32(26))]);
  let ptr9: ptr<workgroup, vec2f> = &vw15.f3;
  textureStore(st2, vec3i(unconst_i32(27), unconst_i32(208), unconst_i32(157)), vec4f(vec4f(unconst_f32(0.1167), unconst_f32(0.3253), unconst_f32(0.01616), unconst_f32(0.5123))));
  vw13 += mat3x4f(bitcast<f32>(vf19), bitcast<f32>(vf19), f32(vf19), bitcast<f32>(vf19), f32(vf19), f32(vf19), bitcast<f32>(vf19), f32(vf19), bitcast<f32>(vf19), bitcast<f32>(vf19), f32(vf19), bitcast<f32>(vf19));
  let ptr10: ptr<workgroup, vec4f> = &vw15.f2;
}`,
  hints: {},
});
let commandEncoder63 = device0.createCommandEncoder();
let texture97 = device0.createTexture({
  label: '\u02c5\u00b1\u71dd\u0cb3',
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView88 = texture8.createView({format: 'rg8uint'});
let sampler31 = device0.createSampler({
  label: '\ucfde\u9e99\u8f23\u042c\u5776',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 46.87,
  lodMaxClamp: 71.09,
  maxAnisotropy: 15,
});
try {
computePassEncoder30.setBindGroup(2, bindGroup12, new Uint32Array(1424), 452, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup22, new Uint32Array(4057), 348, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder11.insertDebugMarker('\u2fc5');
} catch {}
try {
device0.queue.writeBuffer(buffer12, 4460, new DataView(new ArrayBuffer(19101)), 3548, 1152);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let buffer47 = device0.createBuffer({size: 8907, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder64 = device0.createCommandEncoder({});
let texture98 = device0.createTexture({
  label: '\uedd9\u0645\u3753\u0113\u0acc',
  size: [27, 4, 3],
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture99 = device0.createTexture({
  size: [13, 2, 38],
  mipLevelCount: 1,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView89 = texture77.createView({dimension: '1d', mipLevelCount: 1});
let computePassEncoder52 = commandEncoder64.beginComputePass({});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup34 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 28, resource: textureView15}, {binding: 162, resource: sampler28}],
});
let commandEncoder65 = device0.createCommandEncoder({});
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 893});
let textureView90 = texture62.createView({
  label: '\ue7fc\ub769\u{1f660}\uff17\u0b0a\u0951\u803c\u0124\u{1fa6d}',
  dimension: 'cube',
  format: 'rgba16uint',
});
let texture100 = device0.createTexture({
  label: '\u{1fa33}\u{1fbcd}\u1b2a\u{1fce9}\u{1f899}\u5963\u7f2e\u0da7',
  size: [13, 10, 16],
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler32 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 94.46,
});
try {
computePassEncoder32.setBindGroup(2, bindGroup8);
} catch {}
try {
computePassEncoder36.setBindGroup(3, bindGroup1, new Uint32Array(2109), 11, 0);
} catch {}
try {
buffer28.unmap();
} catch {}
try {
commandEncoder65.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 15},
  aspect: 'all',
},
{
  texture: texture72,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture101 = device0.createTexture({
  size: [13, 2, 99],
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler33 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 46.40,
  compare: 'always',
});
try {
computePassEncoder37.setBindGroup(0, bindGroup6, new Uint32Array(107), 10, 0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, buffer17, 16, 1_254);
} catch {}
try {
  await promise4;
} catch {}
let texture102 = device0.createTexture({
  size: [26, 20, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder53 = commandEncoder63.beginComputePass();
let sampler34 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMaxClamp: 84.95,
});
try {
renderPassEncoder12.setIndexBuffer(buffer43, 'uint32', 32, 11);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer3, 72);
} catch {}
let texture103 = device0.createTexture({
  label: '\u822c\ue3f5\u5bce\u8705\u56f5\ude72\u0433',
  size: {width: 13, height: 2, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder13 = commandEncoder65.beginRenderPass({colorAttachments: [{view: textureView10, loadOp: 'clear', storeOp: 'store'}]});
try {
computePassEncoder34.setBindGroup(1, bindGroup11);
} catch {}
try {
computePassEncoder52.setBindGroup(1, bindGroup31, new Uint32Array(2058), 19, 0);
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
try {
  await promise2;
} catch {}
let buffer48 = device0.createBuffer({size: 1209, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let texture104 = device0.createTexture({
  size: [110, 16, 72],
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture105 = device0.createTexture({
  size: [27, 4, 47],
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView91 = texture83.createView({label: '\u{1fedd}\u0a28\u0272\u63ab\u07c6\u03a6\u04db\u7c91\u6ce0\u2c8c\u{1ffaa}', mipLevelCount: 1});
try {
computePassEncoder27.setBindGroup(3, bindGroup22);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(5);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let texture106 = device0.createTexture({
  size: [52, 40, 9],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView92 = texture78.createView({baseArrayLayer: 0, arrayLayerCount: 1});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
});
let sampler35 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'clamp-to-edge', lodMinClamp: 95.85, lodMaxClamp: 98.17});
try {
computePassEncoder25.setBindGroup(1, bindGroup25, new Uint32Array(1302), 7, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup7, new Uint32Array(1424), 296, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, buffer8, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
renderBundleEncoder8.insertDebugMarker('\u084e');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
document.body.append(canvas0);
let texture107 = device0.createTexture({
  label: '\u0789\u0a01\ue399\u0a6d\u9daa',
  size: {width: 110, height: 16, depthOrArrayLayers: 25},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture108 = device0.createTexture({
  size: [104, 80, 1],
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderBundleEncoder8.setBindGroup(3, bindGroup19);
} catch {}
let commandEncoder66 = device0.createCommandEncoder({});
let texture109 = device0.createTexture({
  size: [104, 80, 1],
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder54 = commandEncoder66.beginComputePass({});
try {
computePassEncoder11.setBindGroup(0, bindGroup31);
} catch {}
try {
computePassEncoder6.setBindGroup(1, bindGroup20, new Uint32Array(918), 228, 0);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer48, 'uint16', 74, 40);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(1, buffer20);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 3156, new BigUint64Array(8620), 3186, 56);
} catch {}
let buffer49 = device0.createBuffer({size: 5684, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let texture110 = device0.createTexture({
  size: [322, 2, 1],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture111 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 16},
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView93 = texture8.createView({label: '\udcf9\u{1fa09}\u7e4d\u{1f7f1}\u3fcf\u04d5'});
let sampler36 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 65.03,
  lodMaxClamp: 94.05,
});
try {
renderPassEncoder8.setBindGroup(0, bindGroup11, new Uint32Array(4146), 128, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer43, 'uint16', 128, 203);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(2, buffer22, 0, 4_406);
} catch {}
try {
  await promise6;
} catch {}
let bindGroup35 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView69},
    {binding: 285, resource: {buffer: buffer8, offset: 0, size: 5123}},
  ],
});
let texture112 = device0.createTexture({
  size: [110, 16, 116],
  format: 'r32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler37 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 19.75,
  lodMaxClamp: 99.97,
  maxAnisotropy: 2,
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer34, 'uint16', 168, 6_075);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer34, 0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup9);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer40, 'uint32', 756, 1_354);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas0);
let buffer50 = device0.createBuffer({
  size: 16252,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let texture113 = device0.createTexture({size: [104, 80, 1], format: 'r32sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let textureView94 = texture61.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let renderBundle8 = renderBundleEncoder8.finish({});
try {
computePassEncoder23.setBindGroup(0, bindGroup31, []);
} catch {}
try {
computePassEncoder18.setBindGroup(2, bindGroup0, new Uint32Array(1868), 172, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup29);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer30, 'uint32', 56, 604);
} catch {}
try {
  await promise9;
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let texture114 = device0.createTexture({
  size: [13, 2, 1],
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture115 = device0.createTexture({size: [52], dimension: '1d', format: 'rg16uint', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder55 = commandEncoder67.beginComputePass({});
let texture116 = device0.createTexture({
  size: [55, 8, 3],
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture117 = gpuCanvasContext1.getCurrentTexture();
let textureView95 = texture110.createView({mipLevelCount: 1});
try {
computePassEncoder51.setBindGroup(0, bindGroup3);
} catch {}
try {
computePassEncoder55.setBindGroup(3, bindGroup31, new Uint32Array(3198), 26, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 1, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture118 = device0.createTexture({
  size: [2, 2, 27],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture119 = device0.createTexture({
  label: '\u3bbe\ub38f',
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
});
let renderBundle9 = renderBundleEncoder9.finish({});
try {
renderPassEncoder11.setBindGroup(3, bindGroup23, new Uint32Array(457), 70, 0);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'film', transfer: 'iec61966-2-1'} });
let texture120 = device0.createTexture({
  label: '\u5848\ufd93\u36c5\u01f2\udb28\u8704\uc555\u95e2\u0a97\u054f',
  size: [110, 16, 25],
  sampleCount: 1,
  format: 'rg32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView96 = texture58.createView({dimension: 'cube-array', baseArrayLayer: 4, arrayLayerCount: 6});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder52.setBindGroup(0, bindGroup6, new Uint32Array(3576), 1_193, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer28, 204, 64);
} catch {}
let bindGroup36 = device0.createBindGroup({
  label: '\u02bc\u{1f688}\u99f1',
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer11, offset: 512, size: 3826}},
    {binding: 37, resource: textureView63},
  ],
});
let buffer51 = device0.createBuffer({label: '\uf669\u01eb\u{1f94f}\u05c3', size: 3521, usage: GPUBufferUsage.MAP_READ});
let textureView97 = texture118.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 4, arrayLayerCount: 12});
try {
computePassEncoder46.setBindGroup(0, bindGroup21);
} catch {}
try {
renderBundleEncoder10.setBindGroup(3, bindGroup15, new Uint32Array(270), 3, 0);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(3, buffer15, 0);
} catch {}
let bindGroup37 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [
    {binding: 196, resource: sampler12},
    {binding: 220, resource: textureView1},
    {binding: 380, resource: textureView62},
    {binding: 206, resource: textureView77},
    {binding: 119, resource: textureView32},
    {binding: 230, resource: textureView62},
    {binding: 74, resource: textureView62},
    {binding: 289, resource: textureView87},
  ],
});
let texture121 = gpuCanvasContext0.getCurrentTexture();
let textureView98 = texture5.createView({dimension: '2d', mipLevelCount: 4});
try {
renderBundleEncoder10.setVertexBuffer(1, buffer37, 0);
} catch {}
let textureView99 = texture64.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder39.setBindGroup(1, bindGroup33, new Uint32Array(1215), 76, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer11);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer3, 'uint32', 0, 53);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(3, buffer8, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 55, height: 8, depthOrArrayLayers: 312}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 17},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet10 = device0.createQuerySet({type: 'occlusion', count: 524});
let renderBundle10 = renderBundleEncoder10.finish();
try {
computePassEncoder38.setBindGroup(0, bindGroup31, []);
} catch {}
try {
computePassEncoder11.setBindGroup(1, bindGroup5, new Uint32Array(57), 0, 0);
} catch {}
let imageData6 = new ImageData(12, 28);
let sampler38 = device0.createSampler({
  label: '\u{1fd5b}\u325a',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 30.16,
});
try {
computePassEncoder25.setBindGroup(1, bindGroup11, new Uint32Array(236), 10, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer34, 0, 8_968);
} catch {}
let texture122 = device0.createTexture({
  size: [27, 4, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture123 = device0.createTexture({size: [1290, 8, 1], format: 'rgb10a2uint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
computePassEncoder16.setBindGroup(3, bindGroup24, []);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup4, new Uint32Array(358), 25, 0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle0, renderBundle6]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer33, 'uint32', 1_160, 10_481);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(6, buffer15);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 7,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 71,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let texture124 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler39 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 38.34,
  maxAnisotropy: 17,
});
try {
renderPassEncoder8.beginOcclusionQuery(50);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, buffer38, 0);
} catch {}
let arrayBuffer4 = buffer0.getMappedRange(144, 0);
document.body.prepend(canvas1);
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte170m', transfer: 'smpteSt4281'} });
try {
globalThis.someLabel = bindGroup4.label;
} catch {}
let textureView100 = texture3.createView({dimension: '2d', baseArrayLayer: 41});
let sampler40 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 54.07,
});
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u5198');
} catch {}
let commandEncoder68 = device0.createCommandEncoder({});
let textureView101 = texture112.createView({format: 'r32sint', baseArrayLayer: 10, arrayLayerCount: 12});
let texture125 = device0.createTexture({
  label: '\ufe92\u6993\ucc7a',
  size: [322, 2, 31],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder56 = commandEncoder68.beginComputePass({});
try {
renderPassEncoder2.setViewport(23.381579978213637, 18.98935575144842, 22.346085399331674, 13.965618116900718, 0.8433976588457078, 0.8557907254754359);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer41, 0, 0);
} catch {}
try {
buffer50.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 55, height: 8, depthOrArrayLayers: 312}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 28, y: 1, z: 15},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder69 = device0.createCommandEncoder({});
let textureView102 = texture81.createView({dimension: '2d-array'});
try {
computePassEncoder24.setBindGroup(0, bindGroup19, new Uint32Array(496), 36, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup18);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle7, renderBundle2]);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer24, 'uint32', 7_352, 2_461);
} catch {}
try {
commandEncoder69.copyTextureToBuffer({
  texture: texture83,
  mipLevel: 1,
  origin: {x: 77, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2992 widthInBlocks: 187 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 496 */
  offset: 496,
  bytesPerRow: 5888,
  buffer: buffer18,
}, {width: 187, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder69.clearBuffer(buffer36, 1496, 1300);
} catch {}
let computePassEncoder57 = commandEncoder69.beginComputePass({label: '\u2083\u{1f95f}\uda7f\uf105\u{1f6bd}'});
try {
renderPassEncoder8.setBindGroup(3, bindGroup11);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer15, 372, 1_605);
} catch {}
let sampler41 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 40.83,
  lodMaxClamp: 55.05,
});
let externalTexture12 = device0.importExternalTexture({source: videoFrame12});
try {
renderPassEncoder3.beginOcclusionQuery(60);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder70 = device0.createCommandEncoder();
try {
computePassEncoder16.setBindGroup(1, bindGroup33);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer1, 'uint32', 2_576, 96);
} catch {}
try {
commandEncoder70.resolveQuerySet(querySet1, 197, 554, buffer47, 0);
} catch {}
let commandEncoder71 = device0.createCommandEncoder({});
let texture126 = device0.createTexture({
  size: [55, 8, 1],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['r16float'],
});
let textureView103 = texture100.createView({dimension: '3d', mipLevelCount: 1});
let computePassEncoder58 = commandEncoder71.beginComputePass({});
try {
computePassEncoder57.setBindGroup(1, bindGroup19, new Uint32Array(2181), 122, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup10, new Uint32Array(134), 15, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture66,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas2 = document.createElement('canvas');
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'gamma22curve'} });
try {
renderPassEncoder1.setViewport(13.480806252105092, 31.4028318895248, 26.51544064503936, 5.27663071831099, 0.35392608483314747, 0.4705392345462089);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup38 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 134, resource: externalTexture6}, {binding: 49, resource: textureView3}],
});
let buffer52 = device0.createBuffer({
  size: 5303,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder72 = device0.createCommandEncoder({});
let textureView104 = texture24.createView({dimension: '3d', mipLevelCount: 1});
let computePassEncoder59 = commandEncoder72.beginComputePass();
let renderPassEncoder14 = commandEncoder70.beginRenderPass({
  colorAttachments: [{
  view: textureView104,
  depthSlice: 250,
  clearValue: { r: -43.16, g: 704.1, b: -70.43, a: -21.45, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
});
let externalTexture13 = device0.importExternalTexture({source: videoFrame12});
try {
renderPassEncoder7.setIndexBuffer(buffer31, 'uint16', 3_902, 169);
} catch {}
try {
renderPassEncoder9.insertDebugMarker('\ua744');
} catch {}
let gpuCanvasContext2 = canvas2.getContext('webgpu');
try {
computePassEncoder41.setBindGroup(1, bindGroup24, new Uint32Array(1507), 820, 0);
} catch {}
try {
computePassEncoder17.setBindGroup(2, bindGroup14);
} catch {}
try {
computePassEncoder17.setBindGroup(3, bindGroup21, new Uint32Array(606), 43, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup38, new Uint32Array(1205), 669, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer16, 'uint32', 880, 3_452);
} catch {}
let buffer53 = device0.createBuffer({size: 5752, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder73 = device0.createCommandEncoder();
let textureView105 = texture118.createView({dimension: 'cube-array', baseArrayLayer: 3, arrayLayerCount: 12});
let sampler42 = device0.createSampler({
  label: '\u0979\u840d\u0ab7\u0711\u3e81\ued5a\udb5c\u{1fb9a}\u5c26\u0179',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMinClamp: 58.98,
  lodMaxClamp: 60.46,
  maxAnisotropy: 1,
});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 5, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 6, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture4.label;
} catch {}
let computePassEncoder60 = commandEncoder73.beginComputePass({});
try {
computePassEncoder26.setBindGroup(1, bindGroup38, new Uint32Array(120), 30, 0);
} catch {}
try {
renderPassEncoder11.setViewport(23.243290172709354, 10.294980498965632, 13.159953383510299, 16.39814850959373, 0.0567221517070009, 0.5106761706846887);
} catch {}
let textureView106 = texture60.createView({dimension: 'cube-array', arrayLayerCount: 6});
let texture127 = device0.createTexture({
  size: [13, 10, 16],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder14.setViewport(54.143373907874924, 7.5355775820184565, 0.5788605514316193, 0.4471159458178632, 0.22267807728532452, 0.3652453325136076);
} catch {}
let commandEncoder74 = device0.createCommandEncoder();
let texture128 = device0.createTexture({
  size: [1290, 8, 125],
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let computePassEncoder61 = commandEncoder74.beginComputePass();
let sampler43 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 79.76,
  lodMaxClamp: 95.59,
  maxAnisotropy: 1,
});
try {
computePassEncoder28.setBindGroup(0, bindGroup3, new Uint32Array(5895), 121, 0);
} catch {}
document.body.append(canvas2);
let buffer54 = device0.createBuffer({
  label: '\u0469\uf225\u0ba0\ud603',
  size: 13153,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture129 = device0.createTexture({
  size: {width: 13},
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView107 = texture58.createView({baseArrayLayer: 1, arrayLayerCount: 7});
try {
computePassEncoder19.setBindGroup(3, bindGroup23);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup14, new Uint32Array(2144), 92, 0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle3, renderBundle7]);
} catch {}
try {
adapter0.label = '\u{1fbc5}\ud0ee\uf848\uf07e\u0591\u0029';
} catch {}
let bindGroup39 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 9, resource: {buffer: buffer6, offset: 0, size: 1854}},
    {binding: 115, resource: textureView37},
    {binding: 107, resource: textureView74},
    {binding: 38, resource: textureView59},
    {binding: 268, resource: textureView7},
    {binding: 245, resource: textureView33},
    {binding: 41, resource: {buffer: buffer28, offset: 1792, size: 436}},
    {binding: 296, resource: textureView65},
  ],
});
let buffer55 = device0.createBuffer({
  size: 1138,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder75 = device0.createCommandEncoder({});
let computePassEncoder62 = commandEncoder75.beginComputePass({});
let sampler44 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 27.51,
  maxAnisotropy: 6,
});
try {
renderPassEncoder4.setIndexBuffer(buffer33, 'uint16', 1_410, 2_105);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(3, buffer6, 1_528, 3_010);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder76 = device0.createCommandEncoder({label: '\u{1fb98}\u0422'});
try {
buffer54.unmap();
} catch {}
try {
commandEncoder76.resolveQuerySet(querySet6, 67, 128, buffer34, 2816);
} catch {}
let texture130 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 24},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let computePassEncoder63 = commandEncoder76.beginComputePass({label: '\u7571\u0048\u0266\u4bc3\uee02\u06b5\u0466\u{1fdf9}\u318a'});
try {
computePassEncoder11.setBindGroup(1, bindGroup3, []);
} catch {}
try {
computePassEncoder51.setBindGroup(1, bindGroup25, new Uint32Array(1873), 529, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder13.setScissorRect(7, 0, 2, 3);
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let texture131 = device0.createTexture({
  size: {width: 55},
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView108 = texture3.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 14});
let sampler45 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 48.65,
  lodMaxClamp: 63.45,
});
try {
renderPassEncoder4.setBindGroup(3, bindGroup8, new Uint32Array(2221), 39, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer25);
} catch {}
try {
commandEncoder77.copyTextureToBuffer({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2596 */
  offset: 2596,
  buffer: buffer9,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt470bg', transfer: 'iec61966-2-1'} });
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 1549});
let texture132 = device0.createTexture({size: [13, 2, 1], format: 'r16float', usage: GPUTextureUsage.COPY_SRC});
let textureView109 = texture28.createView({});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  stencilReadOnly: true,
});
let sampler46 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 19.56,
  lodMaxClamp: 20.10,
});
try {
renderPassEncoder3.setVertexBuffer(2, buffer3, 20, 76);
} catch {}
let commandEncoder78 = device0.createCommandEncoder();
let computePassEncoder64 = commandEncoder77.beginComputePass({});
let sampler47 = device0.createSampler({
  label: '\u1117\u6d1b\u{1fd83}\u{1f8df}\u32a4\u607a\uf59a\uf654\u{1f6ee}\u{1f943}\u15f5',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 8.418,
  lodMaxClamp: 71.04,
  maxAnisotropy: 15,
});
try {
renderPassEncoder12.setBindGroup(0, bindGroup10, new Uint32Array(205), 25, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, buffer38, 464, 86);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
commandEncoder78.copyBufferToBuffer(buffer2, 2164, buffer50, 5960, 476);
} catch {}
try {
commandEncoder78.resolveQuerySet(querySet3, 1, 0, buffer29, 28160);
} catch {}
let buffer56 = device0.createBuffer({
  label: '\uf803\u{1fcc6}\u09da\uf140\ucad5\ubd73',
  size: 3652,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let sampler48 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 30.54,
  lodMaxClamp: 89.97,
  compare: 'less',
});
try {
renderPassEncoder10.setIndexBuffer(buffer1, 'uint32', 1_688, 611);
} catch {}
try {
renderBundleEncoder11.setBindGroup(2, bindGroup0, new Uint32Array(1583), 104, 0);
} catch {}
try {
computePassEncoder18.label = '\u{1f9bc}\u{1fd24}\u06e2\u785a\ufa01\uf6f0\u{1f9d9}\u74c5\u{1fcef}\u9acb\ub994';
} catch {}
let buffer57 = device0.createBuffer({size: 2283, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let commandEncoder79 = device0.createCommandEncoder();
let renderBundle11 = renderBundleEncoder11.finish();
try {
renderPassEncoder11.setIndexBuffer(buffer43, 'uint32', 148, 702);
} catch {}
let commandEncoder80 = device0.createCommandEncoder();
let texture133 = device0.createTexture({size: [27], mipLevelCount: 1, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
let textureView110 = texture3.createView({dimension: '2d', baseArrayLayer: 29});
let computePassEncoder65 = commandEncoder80.beginComputePass({});
try {
renderPassEncoder7.setBindGroup(3, bindGroup17, new Uint32Array(2435), 217, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle1, renderBundle4]);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(3, buffer40, 136);
} catch {}
try {
commandEncoder78.insertDebugMarker('\u836d');
} catch {}
let buffer58 = device0.createBuffer({size: 2058, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder81 = device0.createCommandEncoder();
try {
computePassEncoder35.setBindGroup(2, bindGroup5);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup4, new Uint32Array(2526), 676, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, undefined);
} catch {}
try {
commandEncoder78.insertDebugMarker('\u{1f6dd}');
} catch {}
let videoFrame15 = new VideoFrame(imageBitmap2, {timestamp: 0});
let texture134 = device0.createTexture({
  label: '\u0dc4\u221b\u0d55\u08b0\u{1fcfb}\u0f8b\u7c69\u192c',
  size: [2, 2, 27],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder0.executeBundles([renderBundle6]);
} catch {}
let videoFrame16 = new VideoFrame(videoFrame1, {timestamp: 0});
let bindGroup40 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 7, resource: {buffer: buffer52, offset: 1792, size: 2306}},
    {binding: 71, resource: {buffer: buffer20, offset: 1024, size: 3384}},
  ],
});
let commandEncoder82 = device0.createCommandEncoder({label: '\ua95a\u57c2\uf0fc\u3257\u0c76'});
let computePassEncoder66 = commandEncoder79.beginComputePass({});
let renderPassEncoder15 = commandEncoder78.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 176.2, g: 209.3, b: 593.5, a: 585.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder11.setVertexBuffer(6, buffer31, 0, 2_549);
} catch {}
try {
commandEncoder82.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 942 */
  offset: 942,
  bytesPerRow: 15104,
  buffer: buffer58,
}, {
  texture: texture133,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer59 = device0.createBuffer({label: '\u5793\u3ac2', size: 53813, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder83 = device0.createCommandEncoder();
let computePassEncoder67 = commandEncoder82.beginComputePass({label: '\u{1f875}\ud571\u07b7\u{1fd37}\ud711\u459a\u2fa5'});
let renderPassEncoder16 = commandEncoder83.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -114.8, g: 959.7, b: -51.53, a: 895.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder19.setBindGroup(3, bindGroup37);
} catch {}
try {
computePassEncoder30.setBindGroup(2, bindGroup24, new Uint32Array(373), 14, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup22);
} catch {}
try {
commandEncoder81.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1192 */
  offset: 1192,
  buffer: buffer54,
}, {
  texture: texture114,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder81.copyTextureToTexture({
  texture: texture129,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture56,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer60 = device0.createBuffer({label: '\u49f5\u771a\u{1fea5}\u{1faa1}\u0c84\u02e6', size: 2325, usage: GPUBufferUsage.COPY_DST});
let commandEncoder84 = device0.createCommandEncoder({label: '\u0650\u902c\u{1f7d7}\u8deb\u049a\ua0f3'});
let computePassEncoder68 = commandEncoder84.beginComputePass({});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
});
let renderBundle12 = renderBundleEncoder12.finish({});
try {
computePassEncoder22.setBindGroup(2, bindGroup21);
} catch {}
try {
computePassEncoder26.setBindGroup(1, bindGroup21, new Uint32Array(2086), 677, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup38);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let imageData7 = new ImageData(24, 40);
let buffer61 = device0.createBuffer({
  size: 26573,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView111 = texture78.createView({dimension: '2d-array'});
let sampler49 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 66.25,
  lodMaxClamp: 68.46,
});
try {
renderPassEncoder0.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup22, new Uint32Array(1885), 6, 0);
} catch {}
try {
buffer39.unmap();
} catch {}
try {
commandEncoder81.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 400 */
  offset: 400,
  buffer: buffer28,
}, {
  texture: texture134,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder81.resolveQuerySet(querySet5, 21, 6, buffer39, 768);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer62 = device0.createBuffer({
  size: 27716,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder69 = commandEncoder81.beginComputePass({});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup10, new Uint32Array(14), 0, 0);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(1, buffer6, 0, 806);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
try {
computePassEncoder51.setBindGroup(2, bindGroup21);
} catch {}
try {
renderPassEncoder15.setBlendConstant({ r: -414.3, g: 35.43, b: 670.7, a: -932.0, });
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer40, 'uint16', 842, 3_311);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer25, 'uint32', 172, 951);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture70,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(120).fill(56), /* required buffer size: 120 */
{offset: 120}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
canvas0.width = 1258;
let textureView112 = texture33.createView({});
let externalTexture14 = device0.importExternalTexture({source: videoFrame9, colorSpace: 'srgb'});
try {
renderPassEncoder0.executeBundles([renderBundle1]);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(4, buffer3, 0, 118);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let textureView113 = texture107.createView({label: '\u{1f7ba}\u7c15', dimension: '2d'});
let sampler50 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 60.13});
try {
computePassEncoder59.setBindGroup(1, bindGroup7, []);
} catch {}
try {
computePassEncoder55.setBindGroup(1, bindGroup8, new Uint32Array(17), 6, 0);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer3, 'uint32', 4, 6);
} catch {}
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470m', transfer: 'unspecified'} });
let texture135 = device0.createTexture({
  label: '\u119d\u{1fbdc}\u07a4\uc7a8',
  size: [1290],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler51 = device0.createSampler({
  label: '\u9f31\u0105\u02b1',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 45.12,
  lodMaxClamp: 47.59,
  maxAnisotropy: 1,
});
try {
computePassEncoder30.setBindGroup(0, bindGroup12, []);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup13, new Uint32Array(801), 123, 0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup8);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup31, new Uint32Array(891), 363, 0);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer18, 'uint32', 536, 5_134);
} catch {}
let commandEncoder85 = device0.createCommandEncoder({});
let computePassEncoder70 = commandEncoder85.beginComputePass({});
try {
computePassEncoder14.setBindGroup(0, bindGroup27);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup37);
} catch {}
try {
device0.queue.writeBuffer(buffer50, 1512, new Int16Array(3120));
} catch {}
document.body.append(canvas1);
let commandEncoder86 = device0.createCommandEncoder();
let texture136 = device0.createTexture({
  size: [13],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder58.setBindGroup(3, bindGroup32);
} catch {}
try {
computePassEncoder58.setBindGroup(0, bindGroup4, new Uint32Array(1477), 25, 0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup22);
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup40, new Uint32Array(3419), 72, 0);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(7, buffer22, 1_520);
} catch {}
try {
buffer54.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer28, 1120, new BigUint64Array(7698), 334, 4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup41 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView21},
    {binding: 285, resource: {buffer: buffer56, offset: 0, size: 3591}},
  ],
});
let computePassEncoder71 = commandEncoder86.beginComputePass({});
try {
renderBundleEncoder13.setBindGroup(1, bindGroup12, new Uint32Array(55), 18, 0);
} catch {}
try {
buffer39.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(131).fill(62), /* required buffer size: 131 */
{offset: 131, bytesPerRow: 21}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer63 = device0.createBuffer({
  label: '\u{1f87f}\u01d4\u{1f68a}\u8846\u0255\u25e1',
  size: 1213,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let textureView114 = texture22.createView({});
let texture137 = device0.createTexture({
  label: '\u{1f8e0}\u40d5\u06fe\u{1f639}\udf13\u0746\u554c\u01f6\uc47f\uc8c7',
  size: [322],
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler52 = device0.createSampler({
  label: '\u492e\u{1fdc5}\ua0b4\ub730\u{1fcbb}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 17.66,
  lodMaxClamp: 81.76,
});
try {
renderPassEncoder9.setBindGroup(3, bindGroup9);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup31, new Uint32Array(3668), 298, 0);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer61, 'uint32', 5_640, 6_147);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(4, buffer15, 0, 845);
} catch {}
let videoFrame18 = new VideoFrame(videoFrame2, {timestamp: 0});
let bindGroup42 = device0.createBindGroup({
  label: '\u{1f7bc}\u008c\u{1fd2e}\u80cd\u{1f821}\u{1fda3}',
  layout: bindGroupLayout13,
  entries: [
    {binding: 220, resource: textureView109},
    {binding: 380, resource: textureView76},
    {binding: 196, resource: sampler28},
    {binding: 230, resource: textureView109},
    {binding: 119, resource: textureView66},
    {binding: 74, resource: textureView76},
    {binding: 289, resource: textureView87},
    {binding: 206, resource: textureView106},
  ],
});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 560});
let sampler53 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 8.134,
  lodMaxClamp: 39.04,
  compare: 'greater',
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(266);
} catch {}
try {
renderPassEncoder14.setBlendConstant({ r: -730.9, g: -520.7, b: 582.6, a: 577.9, });
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer33, 'uint16', 2_638, 1_333);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer18, 'uint16', 1_076, 2_464);
} catch {}
document.body.append(canvas1);
let textureView115 = texture85.createView({label: '\u{1f83e}\u5f13\u3641\u0fb5\u08bc\u1dc2\u044c\u{1f9bf}\u0b23\u00c1'});
let textureView116 = texture25.createView({});
try {
renderPassEncoder16.setIndexBuffer(buffer48, 'uint32', 300, 63);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup29, new Uint32Array(1827), 474, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'srgb',
});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder87 = device0.createCommandEncoder({label: '\u0073\u5229\u{1fb49}\u{1fb51}\u{1fd69}\u04b2'});
let textureView117 = texture35.createView({label: '\u6f5a\u25b1'});
let computePassEncoder72 = commandEncoder87.beginComputePass({label: '\u{1feb8}\u0aa7\u{1f71a}\u0f37\u0c4a\u0255'});
let renderBundle13 = renderBundleEncoder13.finish({});
let sampler54 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 49.48});
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture118,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(20_218).fill(71), /* required buffer size: 20_218 */
{offset: 346, bytesPerRow: 36, rowsPerImage: 69}, {width: 0, height: 0, depthOrArrayLayers: 9});
} catch {}
let texture138 = device0.createTexture({
  size: {width: 27},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder51.setBindGroup(0, bindGroup26);
} catch {}
try {
computePassEncoder14.pushDebugGroup('\u0fcb');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture116,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(297).fill(215), /* required buffer size: 297 */
{offset: 297, bytesPerRow: 55}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
let commandEncoder88 = device0.createCommandEncoder({label: '\u2d13\u0bec\u0ed4\u{1f8ae}\u2ffc\uc4ed\u0835'});
let texture139 = device0.createTexture({size: {width: 322}, dimension: '1d', format: 'r16float', usage: GPUTextureUsage.TEXTURE_BINDING});
let sampler55 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 44.55,
  lodMaxClamp: 93.11,
  compare: 'never',
  maxAnisotropy: 2,
});
try {
device0.queue.writeTexture({
  texture: texture126,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(230).fill(169), /* required buffer size: 230 */
{offset: 230, bytesPerRow: 151}, {width: 9, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
let buffer64 = device0.createBuffer({
  size: 1060,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let computePassEncoder73 = commandEncoder88.beginComputePass({});
try {
computePassEncoder16.setBindGroup(1, bindGroup31);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(83);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
  await promise10;
} catch {}
await gc();
let bindGroupLayout15 = device0.createBindGroupLayout({
  label: '\u{1fa93}\ue229\u{1f8de}\u3e4f\ua2e5\u0fa4\u{1fe12}\u15cd\u668e',
  entries: [
    {
      binding: 61,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
try {
computePassEncoder12.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder12.setBindGroup(3, bindGroup22, new Uint32Array(1719), 3, 0);
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(488, 321);
let buffer65 = device0.createBuffer({size: 7900, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture140 = device0.createTexture({
  size: {width: 104},
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView118 = texture134.createView({
  label: '\u7b85\u0caf\ud79d\ub47c\u066e\u03e5\u{1f984}\u040b\u{1f77d}',
  dimension: '2d',
  format: 'rgba32sint',
  baseArrayLayer: 4,
});
try {
computePassEncoder40.setBindGroup(3, bindGroup13, new Uint32Array(2269), 21, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup18);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle1, renderBundle3, renderBundle5]);
} catch {}
let imageData8 = new ImageData(28, 44);
let textureView119 = texture68.createView({baseArrayLayer: 2, arrayLayerCount: 1});
try {
renderPassEncoder15.executeBundles([renderBundle4, renderBundle6]);
} catch {}
try {
renderPassEncoder1.setScissorRect(25, 4, 4, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder89 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({
  size: [322, 2, 53],
  mipLevelCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView120 = texture49.createView({label: '\u5051\u1221\u33de\u5d59\u0104\u0e49\u{1f8c6}\u0cb4', dimension: '3d'});
try {
computePassEncoder31.setBindGroup(1, bindGroup40);
} catch {}
try {
computePassEncoder30.setBindGroup(0, bindGroup6, new Uint32Array(2396), 158, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup26, new Uint32Array(908), 71, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer31);
} catch {}
await gc();
let imageBitmap3 = await createImageBitmap(videoFrame15);
let buffer66 = device0.createBuffer({
  size: 65536,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture142 = device0.createTexture({
  size: {width: 110},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer67: vec2f;

@group(0) @binding(38) var st4: texture_storage_3d<rg32float, write>;

@group(0) @binding(41) var<storage, read> buffer68: array<array<f16, 2>, 1>;

@group(0) @binding(107) var tex8: texture_1d<u32>;

@group(0) @binding(115) var tex9: texture_1d<i32>;

@group(0) @binding(245) var st5: texture_storage_3d<r32uint, read>;

@group(0) @binding(268) var tex10: texture_2d_array<u32>;

@group(0) @binding(296) var tex11: texture_2d<u32>;

struct T0 {
  f0: vec2u,
}

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

struct VertexOutput3 {
  @location(13) f10: vec4h,
  @location(4) @interpolate(flat, center) f11: vec2i,
  @invariant @builtin(position) f12: vec4f,
}

struct FragmentOutput0 {
  @location(4) f0: vec4f,
  @location(3) f1: vec4f,
  @location(1) @interpolate(flat) f2: f32,
  @location(5) f3: f32,
  @location(0) f4: vec2u,
  @location(2) @interpolate(flat) f5: vec4u,
}

fn fn0() -> f16 {
  var out: f16;
  let ptr11: ptr<storage, array<f16, 2>, read> = &buffer68[0];
  let ptr12: ptr<storage, array<f16, 2>, read> = &buffer68[u32(unconst_u32(176))];
  let ptr13: ptr<storage, array<f16, 2>, read> = &buffer68[0];
  let ptr14: ptr<storage, f16, read> = &(*&buffer68)[u32(unconst_u32(53))][u32(unconst_u32(299))];
  let ptr15: ptr<storage, f16, read> = &buffer68[0][1];
  out = (*ptr11)[1];
  let vf20: f16 = sign(f16(unconst_f16(5668.7)));
  out = fma(vec4h(unconst_f16(6901.2), unconst_f16(27742.9), unconst_f16(13326.4), unconst_f16(3844.7)), vec4h(unconst_f16(25799.3), unconst_f16(5011.5), unconst_f16(52268.4), unconst_f16(7049.8)), vec4h(unconst_f16(25834.8), unconst_f16(7981.0), unconst_f16(17624.5), unconst_f16(3741.6))).a;
  let ptr16: ptr<storage, f16, read> = &buffer68[pack4xI8(bitcast<vec4i>(inverseSqrt(vec3f(unconst_f32(-0.3283), unconst_f32(0.2557), unconst_f32(0.07836))).rgbb))][u32(unconst_u32(22))];
  let ptr17: ptr<storage, array<f16, 2>, read> = &(*ptr13);
  let ptr18: ptr<storage, f16, read> = &buffer68[u32(unconst_u32(97))][1];
  let vf21: u32 = dot4U8Packed(u32(unconst_u32(513)), u32(unconst_u32(232)));
  let ptr19: ptr<storage, f16, read> = &(*ptr13)[u32(unconst_u32(502))];
  out = atan((*&buffer68)[0][1]);
  let vf22: vec4f = unpack4x8snorm(u32(unconst_u32(304)));
  let ptr20: ptr<storage, array<f16, 2>, read> = &(*ptr12);
  out = (*ptr16);
  let ptr21: ptr<storage, array<f16, 2>, read> = &(*&buffer68)[u32(unconst_u32(84))];
  let ptr22: ptr<storage, array<f16, 2>, read> = &buffer68[0];
  out = (*ptr17)[1];
  let ptr23: ptr<storage, f16, read> = &(*ptr13)[1];
  let ptr24: ptr<storage, f16, read> = &(*ptr21)[1];
  let ptr25: ptr<storage, f16, read> = &(*ptr14);
  let ptr26: ptr<storage, array<f16, 2>, read> = &buffer68[u32(unconst_u32(200))];
  return out;
}

@vertex
fn vertex3(@location(7) a0: vec2u) -> VertexOutput3 {
  var out: VertexOutput3;
  out.f10 -= vec4h((*&buffer68)[0][1]);
  var vf23 = fn0();
  vf23 = buffer68[0][1];
  let ptr27: ptr<storage, f16, read> = &(*&buffer68)[0][1];
  fn0();
  return out;
}

@fragment
fn fragment1() -> FragmentOutput0 {
  var out: FragmentOutput0;
  out.f3 += ldexp(vec3f(unconst_f32(0.00965), unconst_f32(0.09921), unconst_f32(0.07185)), vec3i(unconst_i32(66), unconst_i32(37), unconst_i32(31))).x;
  out.f1 *= vec4f(trunc(vec3h(unconst_f16(453.0), unconst_f16(21740.1), unconst_f16(22757.1))).yxyz);
  var vf24 = fn0();
  let vf25: vec4i = firstLeadingBit(vec4i(unconst_i32(92), unconst_i32(21), unconst_i32(36), unconst_i32(-1)));
  out = FragmentOutput0(vec4f(f32(textureNumLevels(tex9))), vec4f(bitcast<f32>(textureNumLevels(tex9))), f32(textureNumLevels(tex9)), bitcast<f32>(textureNumLevels(tex9)), vec2u(textureNumLevels(tex9)), vec4u(textureNumLevels(tex9)));
  let vf26: vec4i = vf25;
  var vf27: vec4i = vf26;
  out.f0 -= vec4f(textureDimensions(tex10, bitcast<vec2i>(firstLeadingBit(vec2u(unconst_u32(168), unconst_u32(22)))).x).xxyy);
  out.f0 -= vec4f(bitcast<f32>(textureNumLevels(tex8)));
  out.f5 = vec4u(u32((*&buffer68)[u32(unconst_u32(32))][pack2x16float(mix(vec2f(unconst_f32(0.00512), unconst_f32(0.1134)), vec2f(unconst_f32(0.4386), unconst_f32(0.8453)), f32(unconst_f32(0.2305))))]));
  var vf28: vec4u = textureLoad(tex11, vec2i(unconst_i32(-34), unconst_i32(263)), i32(unconst_i32(256)));
  out.f3 = vec4f(vf28).y;
  let vf29: vec4i = vf25;
  var vf30: vec4i = firstLeadingBit(vec4i(unconst_i32(406), unconst_i32(10), unconst_i32(333), unconst_i32(101)));
  let ptr28: ptr<storage, f16, read> = &(*&buffer68)[0][u32(unconst_u32(169))];
  let vf31: u32 = textureNumLayers(tex10);
  let ptr29: ptr<storage, array<f16, 2>, read> = &buffer68[0];
  textureStore(st4, vec3i(unconst_i32(173), unconst_i32(455), unconst_i32(178)), vec4f(vec4f(unconst_f32(0.1453), unconst_f32(-0.3283), unconst_f32(0.04042), unconst_f32(-0.1418))));
  let vf32: i32 = vf29[u32(unconst_u32(211))];
  var vf33: f32 = buffer67[u32(unconst_u32(130))];
  let ptr30: ptr<storage, f16, read> = &(*ptr29)[1];
  let vf34: vec4i = firstLeadingBit(vec4i(unconst_i32(884), unconst_i32(15), unconst_i32(418), unconst_i32(-38)));
  out.f4 -= vec2u(u32((*ptr29)[1]));
  let ptr31: ptr<storage, f16, read> = &(*&buffer68)[u32(unconst_u32(161))][u32(unconst_u32(161))];
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let textureView121 = texture33.createView({baseArrayLayer: 0, arrayLayerCount: 1});
let sampler56 = device0.createSampler({
  label: '\u5aeb\uabc8',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 9.303,
  lodMaxClamp: 29.88,
});
try {
computePassEncoder30.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle1]);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let imageData9 = new ImageData(16, 108);
try {
device0.label = '\u59c4\u0d63\u0243\u6c28\ucd59\u0440\u{1f606}\u0d0e\u0312\ubdd7';
} catch {}
let texture143 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView122 = texture78.createView({dimension: '2d-array'});
let sampler57 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 78.00,
  lodMaxClamp: 78.74,
  compare: 'not-equal',
  maxAnisotropy: 5,
});
try {
computePassEncoder70.setBindGroup(3, bindGroup16, []);
} catch {}
try {
renderPassEncoder10.setViewport(7.180002413322262, 0.09929826096878536, 5.878236425457193, 35.502720737475926, 0.2751211440892595, 0.8517299154505059);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer24, 'uint16', 3_456, 7_662);
} catch {}
try {
commandEncoder89.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1394 */
  offset: 1394,
  buffer: buffer42,
}, {
  texture: texture57,
  mipLevel: 0,
  origin: {x: 1, y: 29, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 4},
  aspect: 'all',
}, new Uint8Array(55).fill(66), /* required buffer size: 55 */
{offset: 55, bytesPerRow: 61}, {width: 7, height: 0, depthOrArrayLayers: 1});
} catch {}
let querySet13 = device0.createQuerySet({type: 'occlusion', count: 901});
let textureView123 = texture118.createView({dimension: '2d', format: 'r32sint', baseArrayLayer: 1});
let computePassEncoder74 = commandEncoder89.beginComputePass();
try {
computePassEncoder29.setBindGroup(1, bindGroup33, new Uint32Array(1470), 497, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0]);
} catch {}
let sampler58 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 67.81,
  compare: 'equal',
});
try {
computePassEncoder22.setBindGroup(3, bindGroup31);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(7, buffer8, 8_636);
} catch {}
try {
computePassEncoder14.popDebugGroup();
} catch {}
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'gamma22curve'} });
let bindGroup43 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 71, resource: {buffer: buffer28, offset: 1024, size: 1752}},
    {binding: 7, resource: {buffer: buffer2, offset: 768}},
  ],
});
let texture144 = device0.createTexture({
  size: [26, 20, 1],
  mipLevelCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder15.setBindGroup(2, bindGroup21);
} catch {}
try {
computePassEncoder46.setBindGroup(3, bindGroup27, new Uint32Array(1895), 18, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle7, renderBundle0, renderBundle3]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer43, 'uint16', 170, 379);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext3 = offscreenCanvas0.getContext('webgpu');
let commandEncoder90 = device0.createCommandEncoder();
let texture145 = device0.createTexture({
  size: [645, 4, 8],
  mipLevelCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder17 = commandEncoder90.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 565.5, g: 21.03, b: 967.5, a: 949.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 250056716,
});
try {
renderPassEncoder16.executeBundles([renderBundle3, renderBundle2, renderBundle2, renderBundle5, renderBundle6]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer39, 'uint32', 9_620, 863);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer20);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture106,
  mipLevel: 0,
  origin: {x: 5, y: 8, z: 5},
  aspect: 'all',
}, new Uint8Array(676).fill(255), /* required buffer size: 676 */
{offset: 164, bytesPerRow: 36}, {width: 4, height: 15, depthOrArrayLayers: 1});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let renderBundle14 = renderBundleEncoder14.finish({});
try {
computePassEncoder51.setBindGroup(3, bindGroup32);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup18);
} catch {}
let imageData10 = new ImageData(16, 60);
let commandEncoder91 = device0.createCommandEncoder({});
let textureView124 = texture77.createView({arrayLayerCount: 1});
try {
renderPassEncoder0.setBindGroup(0, bindGroup26);
} catch {}
try {
commandEncoder91.copyBufferToTexture({
  /* bytesInLastRow: 288 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 176 */
  offset: 176,
  rowsPerImage: 520,
  buffer: buffer10,
}, {
  texture: texture116,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 18, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer69 = device0.createBuffer({size: 4405, usage: GPUBufferUsage.MAP_READ});
let commandEncoder92 = device0.createCommandEncoder({label: '\u{1f601}\u02c4\u77ca\u0788\uc836\u7e5c'});
let texture146 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 16},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture147 = device0.createTexture({
  label: '\u0cc0\ub1e5\u0575\u{1faad}\u{1fea7}\u5914\ufc61\uf949\u{1ffb2}',
  size: [13, 2, 78],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView125 = texture69.createView({baseArrayLayer: 2, arrayLayerCount: 12});
let renderPassEncoder18 = commandEncoder92.beginRenderPass({
  colorAttachments: [{
  view: textureView104,
  depthSlice: 22,
  clearValue: { r: -225.8, g: 962.7, b: 706.3, a: -690.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let sampler59 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 77.63,
  maxAnisotropy: 8,
});
try {
computePassEncoder17.setBindGroup(1, bindGroup3);
} catch {}
document.body.prepend(canvas1);
let bindGroup44 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 232, resource: {buffer: buffer14, offset: 512, size: 1216}},
    {binding: 161, resource: textureView76},
    {binding: 141, resource: textureView90},
    {binding: 38, resource: sampler13},
    {binding: 216, resource: {buffer: buffer5, offset: 512}},
    {binding: 68, resource: {buffer: buffer5, offset: 768}},
    {binding: 62, resource: sampler57},
    {binding: 384, resource: externalTexture14},
    {binding: 67, resource: textureView1},
    {binding: 49, resource: {buffer: buffer40, offset: 0, size: 1900}},
    {binding: 47, resource: sampler29},
    {binding: 712, resource: {buffer: buffer62, offset: 7936}},
    {binding: 330, resource: {buffer: buffer12, offset: 4096, size: 4807}},
    {binding: 112, resource: textureView61},
    {binding: 348, resource: textureView109},
    {binding: 55, resource: {buffer: buffer43, offset: 0, size: 40}},
    {binding: 408, resource: textureView74},
    {binding: 162, resource: textureView86},
    {binding: 95, resource: sampler40},
    {binding: 54, resource: externalTexture8},
    {binding: 65, resource: textureView100},
    {binding: 8, resource: textureView61},
    {binding: 125, resource: textureView110},
    {binding: 697, resource: {buffer: buffer49, offset: 1024}},
    {binding: 29, resource: sampler55},
    {binding: 209, resource: textureView12},
    {binding: 479, resource: externalTexture12},
    {binding: 228, resource: {buffer: buffer49, offset: 0}},
    {binding: 99, resource: {buffer: buffer10, offset: 6656, size: 1854}},
    {binding: 117, resource: {buffer: buffer5, offset: 2048, size: 766}},
    {binding: 36, resource: sampler35},
    {binding: 20, resource: externalTexture4},
    {binding: 2, resource: textureView76},
    {binding: 142, resource: textureView25},
    {binding: 33, resource: textureView74},
    {binding: 328, resource: textureView109},
    {binding: 135, resource: externalTexture4},
    {binding: 15, resource: textureView109},
    {binding: 195, resource: textureView10},
    {binding: 118, resource: textureView108},
    {binding: 5, resource: textureView44},
    {binding: 34, resource: sampler14},
    {binding: 318, resource: {buffer: buffer52, offset: 256, size: 144}},
    {binding: 61, resource: textureView5},
  ],
});
let buffer70 = device0.createBuffer({
  label: '\u093b\u8645\u7ced\u{1fb47}\u22b5',
  size: 6033,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder93 = device0.createCommandEncoder({});
let computePassEncoder75 = commandEncoder93.beginComputePass({});
let renderPassEncoder19 = commandEncoder91.beginRenderPass({
  label: '\uc25e\u3bf1\u6bfa\u0c59\ua1bb\u0796\u056a\u6304\u0e64',
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: 520.1, g: 834.4, b: 323.4, a: -486.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
device0.queue.writeBuffer(buffer48, 32, new DataView(new ArrayBuffer(11294)), 961, 436);
} catch {}
await gc();
let bindGroup45 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 71, resource: {buffer: buffer13, offset: 5888, size: 2928}},
    {binding: 7, resource: {buffer: buffer62, offset: 3328}},
  ],
});
try {
computePassEncoder0.setBindGroup(1, bindGroup24, new Uint32Array(1340), 44, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup23, new Uint32Array(1603), 153, 0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle5]);
} catch {}
let buffer71 = device0.createBuffer({size: 4344, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture148 = device0.createTexture({
  size: [322, 2, 154],
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder15.setBindGroup(2, bindGroup35);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer40, 'uint16', 3_630, 248);
} catch {}
let buffer72 = device0.createBuffer({size: 18607, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
try {
renderPassEncoder0.setBindGroup(3, bindGroup30);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle2, renderBundle6, renderBundle14, renderBundle5]);
} catch {}
let commandEncoder94 = device0.createCommandEncoder({});
let texture149 = device0.createTexture({
  label: '\u0661\u57ad\u7cf9\u2ba7',
  size: {width: 55, height: 8, depthOrArrayLayers: 312},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder68.setBindGroup(1, bindGroup29);
} catch {}
try {
commandEncoder94.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1276 */
  offset: 1276,
  buffer: buffer2,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let buffer73 = device0.createBuffer({size: 3458, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let computePassEncoder76 = commandEncoder94.beginComputePass({});
try {
device0.pushErrorScope('validation');
} catch {}
let bindGroup46 = device0.createBindGroup({
  label: '\u5e95\u6ded\u9043\u069c\ub8d4\u{1fcb7}\u{1fa09}',
  layout: bindGroupLayout10,
  entries: [
    {binding: 118, resource: textureView3},
    {binding: 67, resource: textureView110},
    {binding: 5, resource: textureView38},
    {binding: 47, resource: sampler2},
    {binding: 125, resource: textureView3},
    {binding: 330, resource: {buffer: buffer20, offset: 0, size: 4889}},
    {binding: 61, resource: textureView0},
    {binding: 161, resource: textureView51},
    {binding: 99, resource: {buffer: buffer31, offset: 0, size: 1065}},
    {binding: 135, resource: externalTexture5},
    {binding: 55, resource: {buffer: buffer5, offset: 512}},
    {binding: 142, resource: textureView27},
    {binding: 117, resource: {buffer: buffer20, offset: 1024, size: 1386}},
    {binding: 15, resource: textureView3},
    {binding: 697, resource: {buffer: buffer52, offset: 1536, size: 80}},
    {binding: 318, resource: {buffer: buffer28, offset: 512, size: 432}},
    {binding: 228, resource: {buffer: buffer33, offset: 2816, size: 3320}},
    {binding: 232, resource: {buffer: buffer5, offset: 256}},
    {binding: 33, resource: textureView74},
    {binding: 162, resource: textureView115},
    {binding: 209, resource: textureView10},
    {binding: 34, resource: sampler35},
    {binding: 38, resource: sampler13},
    {binding: 95, resource: sampler40},
    {binding: 328, resource: textureView10},
    {binding: 112, resource: textureView61},
    {binding: 216, resource: {buffer: buffer20, offset: 256, size: 6377}},
    {binding: 2, resource: textureView76},
    {binding: 65, resource: textureView109},
    {binding: 384, resource: externalTexture7},
    {binding: 29, resource: sampler55},
    {binding: 408, resource: textureView54},
    {binding: 68, resource: {buffer: buffer62, offset: 6912, size: 5580}},
    {binding: 348, resource: textureView65},
    {binding: 141, resource: textureView75},
    {binding: 62, resource: sampler33},
    {binding: 36, resource: sampler12},
    {binding: 49, resource: {buffer: buffer18, offset: 0, size: 1904}},
    {binding: 20, resource: externalTexture4},
    {binding: 479, resource: externalTexture6},
    {binding: 195, resource: textureView10},
    {binding: 54, resource: externalTexture3},
    {binding: 8, resource: textureView61},
    {binding: 712, resource: {buffer: buffer48, offset: 0, size: 628}},
  ],
});
let commandEncoder95 = device0.createCommandEncoder({label: '\u5198\u0761\u8862\u52d5\u49c5\u0de6\u0ffe\ud4fd\u9e57\u{1fcdd}'});
try {
renderPassEncoder1.setBindGroup(3, bindGroup31, []);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer54, 0);
} catch {}
try {
commandEncoder95.clearBuffer(buffer1, 12, 540);
} catch {}
try {
commandEncoder95.insertDebugMarker('\u1b9a');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture103,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(754).fill(133), /* required buffer size: 754 */
{offset: 754}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture150 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 141},
  mipLevelCount: 3,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder27.setBindGroup(0, bindGroup35, new Uint32Array(523), 142, 0);
} catch {}
try {
renderPassEncoder8.setStencilReference(861);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let buffer74 = device0.createBuffer({size: 2205, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder96 = device0.createCommandEncoder({label: '\u0356\u{1f7e6}\ufac8\u0292\u6c05\u9b38\u{1fc57}'});
let textureView126 = texture32.createView({dimension: '2d'});
let computePassEncoder77 = commandEncoder96.beginComputePass({});
let renderPassEncoder20 = commandEncoder95.beginRenderPass({colorAttachments: [{view: textureView45, loadOp: 'clear', storeOp: 'store'}]});
try {
computePassEncoder22.end();
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup23);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer30, 'uint32', 640, 83);
} catch {}
try {
commandEncoder27.resolveQuerySet(querySet6, 34, 94, buffer35, 256);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture133,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(5).fill(138), /* required buffer size: 5 */
{offset: 5}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup47 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView63},
    {binding: 285, resource: {buffer: buffer1, offset: 0, size: 5182}},
  ],
});
let computePassEncoder78 = commandEncoder27.beginComputePass({});
try {
renderPassEncoder2.setBindGroup(1, bindGroup23);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup9, new Uint32Array(591), 24, 0);
} catch {}
let texture151 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 11},
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
let bindGroup48 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let textureView127 = texture36.createView({label: '\u52fb\u42b3\u032e'});
try {
computePassEncoder36.setBindGroup(2, bindGroup27);
} catch {}
try {
computePassEncoder47.end();
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(2, undefined, 399_429_976, 3_261_438_392);
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture149,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 111},
  aspect: 'all',
},
{
  texture: texture100,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder58.resolveQuerySet(querySet2, 904, 178, buffer35, 0);
} catch {}
let commandEncoder97 = device0.createCommandEncoder({});
let texture152 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder74.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle1, renderBundle1, renderBundle6]);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer42, 0, 110);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer75 = device0.createBuffer({
  size: 23722,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder98 = device0.createCommandEncoder({});
let texture153 = device0.createTexture({
  size: [52],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView128 = texture151.createView({label: '\u0db5\u{1fa27}\u41dc\u4656\u052f\u31af', dimension: '2d', mipLevelCount: 1});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
});
let sampler60 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 46.60,
  lodMaxClamp: 63.19,
  maxAnisotropy: 5,
});
try {
renderPassEncoder13.setBlendConstant({ r: -26.68, g: -538.4, b: 316.7, a: 149.8, });
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let commandEncoder99 = device0.createCommandEncoder({label: '\u{1f65f}\u6aea\u02d6\u065f\ubd71'});
let textureView129 = texture148.createView({aspect: 'all', baseArrayLayer: 16, arrayLayerCount: 59});
let renderPassEncoder21 = commandEncoder58.beginRenderPass({colorAttachments: [{view: textureView45, loadOp: 'load', storeOp: 'store'}]});
try {
commandEncoder97.copyTextureToTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 14, y: 1, z: 45},
  aspect: 'all',
},
{
  texture: texture12,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer76 = device0.createBuffer({size: 45676, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let texture154 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder72.setBindGroup(3, bindGroup37, new Uint32Array(760), 73, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup26);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer72, 'uint16', 1_330, 41);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup41, new Uint32Array(1841), 464, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture66,
  mipLevel: 1,
  origin: {x: 148, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(89).fill(175), /* required buffer size: 89 */
{offset: 89, rowsPerImage: 45}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas2);
let buffer77 = device0.createBuffer({
  label: '\u014e\u{1fdb3}\u{1fd13}\u{1fdbc}\u09f4\ue08d\u{1fe61}\u05ac',
  size: 5758,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture155 = device0.createTexture({
  size: {width: 55, height: 8, depthOrArrayLayers: 37},
  mipLevelCount: 4,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder79 = commandEncoder97.beginComputePass({});
let renderBundle15 = renderBundleEncoder15.finish({});
try {
computePassEncoder41.setBindGroup(3, bindGroup15, new Uint32Array(2307), 225, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle2, renderBundle7]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
document.body.prepend(canvas2);
let computePassEncoder80 = commandEncoder99.beginComputePass({});
try {
renderPassEncoder21.setBindGroup(2, bindGroup25, new Uint32Array(249), 19, 0);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(3, buffer42);
} catch {}
let canvas3 = document.createElement('canvas');
let bindGroup49 = device0.createBindGroup({
  label: '\u402c\u{1f6b4}\u75fb',
  layout: bindGroupLayout4,
  entries: [
    {binding: 7, resource: textureView15},
    {binding: 136, resource: textureView114},
    {binding: 124, resource: textureView42},
    {binding: 112, resource: sampler53},
    {binding: 29, resource: textureView26},
  ],
});
let texture156 = device0.createTexture({
  label: '\u2122\ua4d3\uec6e\ufc16\u61bd\u31f5\u3a38\u{1feef}\ud97c\u05df\u0dfe',
  size: {width: 110, height: 16, depthOrArrayLayers: 16},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder81 = commandEncoder98.beginComputePass({});
try {
renderPassEncoder15.setBindGroup(2, bindGroup41, []);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup23, new Uint32Array(1381), 62, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer74, 'uint32', 204, 541);
} catch {}
let gpuCanvasContext4 = canvas3.getContext('webgpu');
let bindGroup50 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer75, offset: 4096, size: 5819}},
    {binding: 37, resource: textureView69},
  ],
});
let buffer78 = device0.createBuffer({
  size: 17519,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture157 = gpuCanvasContext1.getCurrentTexture();
let textureView130 = texture53.createView({baseMipLevel: 0});
let sampler61 = device0.createSampler({
  label: '\ub249\u5be8\u0f07\uf5e3\u2ff4\u{1fa49}\u3fab',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 82.89,
  lodMaxClamp: 88.31,
});
try {
computePassEncoder2.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup6, new Uint32Array(2456), 446, 0);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(7, buffer21, 0, 1_805);
} catch {}
let commandEncoder100 = device0.createCommandEncoder({label: '\uc93f\u21e5\uf286\u{1fe7a}\u8e6d\udf8e\u0f2b\u91e0\u0fee\u0531'});
let texture158 = device0.createTexture({
  size: [1290],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder82 = commandEncoder100.beginComputePass({label: '\u9d61\ue9f2'});
try {
computePassEncoder51.setBindGroup(2, bindGroup25);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer34);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer44.unmap();
} catch {}
canvas2.height = 118;
let buffer79 = device0.createBuffer({
  size: 21914,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView131 = texture110.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder2.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle1]);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST});
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470bg', transfer: 'logSqrt'} });
try {
textureView80.label = '\u03b2\u6a74\u88e5\u0d25\ubd19';
} catch {}
let bindGroup51 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler28}, {binding: 28, resource: textureView109}],
});
let buffer80 = device0.createBuffer({
  size: 6116,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder101 = device0.createCommandEncoder({});
let computePassEncoder83 = commandEncoder101.beginComputePass({});
try {
renderPassEncoder10.setBindGroup(3, bindGroup36);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup41, new Uint32Array(1477), 136, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer2);
} catch {}
try {
  await shaderModule2.getCompilationInfo();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(114_317).fill(85), /* required buffer size: 114_317 */
{offset: 65, bytesPerRow: 84, rowsPerImage: 104}, {width: 6, height: 9, depthOrArrayLayers: 14});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup52 = device0.createBindGroup({
  label: '\u081c\u0c94\u3715\ua836\u086e',
  layout: bindGroupLayout15,
  entries: [{binding: 61, resource: textureView12}],
});
let buffer81 = device0.createBuffer({
  size: 9900,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder102 = device0.createCommandEncoder({});
let textureView132 = texture138.createView({label: '\u0771\u430a\u356e\u0399\u0135\u0d84\uff92\u{1f857}\u0f8f\u8c4c\u79e2'});
let textureView133 = texture15.createView({});
try {
computePassEncoder82.setBindGroup(1, bindGroup29);
} catch {}
try {
computePassEncoder15.setBindGroup(3, bindGroup18, new Uint32Array(290), 11, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup42, new Uint32Array(1245), 101, 0);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(99);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(3, undefined, 1_357_078_049);
} catch {}
try {
commandEncoder102.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 452 */
  offset: 452,
  rowsPerImage: 1031,
  buffer: buffer38,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder103 = device0.createCommandEncoder();
let texture159 = device0.createTexture({
  size: [104, 80, 128],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder84 = commandEncoder102.beginComputePass({});
try {
renderPassEncoder3.setBindGroup(3, bindGroup19, new Uint32Array(464), 24, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer79, 'uint16', 818, 5_780);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer12, 2928, new Int16Array(23494), 3320, 736);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let textureView134 = texture85.createView({label: '\u0ca9\u{1f828}\u0c6b\u542f\ue1fc\u{1fc78}'});
let computePassEncoder85 = commandEncoder103.beginComputePass({});
let sampler62 = device0.createSampler({
  label: '\u7b90\u9098\u582f',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 93.68,
  compare: 'never',
});
let externalTexture15 = device0.importExternalTexture({source: videoFrame11});
try {
renderPassEncoder11.setIndexBuffer(buffer33, 'uint16', 5_416, 563);
} catch {}
document.body.prepend(canvas3);
let bindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 79,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 190,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '2d' },
    },
    {binding: 163, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 110,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 389,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 160,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 47,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 306,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 349,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 196,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 523,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 351,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 287,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 14,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', minBindingSize: 245, hasDynamicOffset: false },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 143,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 70,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 88,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 195,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {binding: 12, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 177,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 185,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 255,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 252,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let texture160 = device0.createTexture({
  size: [26, 20, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler63 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 88.50,
  compare: 'equal',
  maxAnisotropy: 5,
});
try {
computePassEncoder54.setBindGroup(3, bindGroup5);
} catch {}
try {
computePassEncoder81.setBindGroup(3, bindGroup33, new Uint32Array(263), 5, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(4);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
let arrayBuffer5 = buffer0.getMappedRange(64, 8);
try {
device0.queue.writeBuffer(buffer9, 136, new Float32Array(2628), 231, 128);
} catch {}
document.body.prepend(canvas3);
let textureView135 = texture160.createView({});
let texture161 = device0.createTexture({
  size: [2, 2, 27],
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder54.setBindGroup(3, bindGroup24);
} catch {}
try {
computePassEncoder31.setBindGroup(1, bindGroup41, new Uint32Array(2586), 360, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup20);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup51, new Uint32Array(713), 97, 0);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
device0.queue.writeBuffer(buffer31, 172, new BigUint64Array(7050), 2669, 28);
} catch {}
let canvas4 = document.createElement('canvas');
let commandEncoder104 = device0.createCommandEncoder({});
let texture162 = device0.createTexture({
  label: '\ud1d9\u{1fb2a}\u0673\u0e45\u0852',
  size: {width: 27, height: 4, depthOrArrayLayers: 66},
  format: 'rgba8snorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture163 = device0.createTexture({size: {width: 55}, dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder78.setBindGroup(1, bindGroup36, new Uint32Array(1079), 338, 0);
} catch {}
try {
commandEncoder104.copyBufferToBuffer(buffer37, 168, buffer80, 1228, 1404);
} catch {}
try {
commandEncoder104.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 286 */
  offset: 286,
  buffer: buffer37,
}, {
  texture: texture106,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder104.resolveQuerySet(querySet0, 25, 0, buffer41, 0);
} catch {}
try {
adapter0.label = '\u{1fb69}\u7822\u{1fb18}\u{1fa49}\u7c2a\uf8aa\u{1f86b}\u7632';
} catch {}
let texture164 = device0.createTexture({
  size: [26, 20, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView136 = texture37.createView({});
let computePassEncoder86 = commandEncoder104.beginComputePass({});
try {
renderPassEncoder4.setVertexBuffer(1, buffer2, 0, 1_848);
} catch {}
let commandEncoder105 = device0.createCommandEncoder({});
let textureView137 = texture162.createView({format: 'rgba8snorm', baseArrayLayer: 3, arrayLayerCount: 21});
let textureView138 = texture139.createView({});
try {
renderPassEncoder2.setIndexBuffer(buffer16, 'uint32', 820, 2_524);
} catch {}
try {
computePassEncoder51.insertDebugMarker('\u{1f7ba}');
} catch {}
document.body.append(canvas3);
let bindGroup53 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 72, resource: {buffer: buffer17, offset: 1536, size: 2612}},
    {binding: 156, resource: textureView65},
    {binding: 0, resource: textureView137},
    {binding: 58, resource: textureView61},
    {binding: 319, resource: externalTexture11},
    {binding: 207, resource: textureView55},
    {binding: 25, resource: {buffer: buffer55, offset: 0, size: 321}},
    {binding: 108, resource: {buffer: buffer16, offset: 14080, size: 954}},
    {binding: 189, resource: textureView82},
    {binding: 268, resource: textureView62},
    {binding: 66, resource: textureView71},
    {binding: 8, resource: {buffer: buffer37, offset: 7680}},
    {binding: 134, resource: textureView72},
    {binding: 495, resource: {buffer: buffer64, offset: 0, size: 302}},
  ],
});
let commandEncoder106 = device0.createCommandEncoder({});
let texture165 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 115},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView139 = texture73.createView({arrayLayerCount: 1});
let computePassEncoder87 = commandEncoder106.beginComputePass({});
try {
computePassEncoder66.setBindGroup(3, bindGroup38, new Uint32Array(1610), 408, 0);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle5, renderBundle0, renderBundle6, renderBundle5, renderBundle0]);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer22);
} catch {}
let gpuCanvasContext5 = canvas4.getContext('webgpu');
let offscreenCanvas1 = new OffscreenCanvas(52, 116);
let textureView140 = texture165.createView({dimension: '2d', format: 'rg32float', baseArrayLayer: 39});
try {
renderPassEncoder4.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(957);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer80, 'uint32', 708, 357);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 728, new DataView(new ArrayBuffer(8751)), 1931, 1332);
} catch {}
let videoFrame21 = new VideoFrame(imageBitmap1, {timestamp: 0});
let commandEncoder107 = device0.createCommandEncoder({});
let texture166 = device0.createTexture({
  size: [27, 4, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView141 = texture161.createView({dimension: '2d', baseArrayLayer: 1});
let computePassEncoder88 = commandEncoder105.beginComputePass({});
let externalTexture16 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder13.setBindGroup(3, bindGroup47, new Uint32Array(2534), 148, 0);
} catch {}
try {
commandEncoder107.copyTextureToTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 107, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture34,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 1},
  aspect: 'all',
},
{width: 52, height: 0, depthOrArrayLayers: 2});
} catch {}
let bindGroup54 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 108, resource: {buffer: buffer77, offset: 512, size: 399}},
    {binding: 58, resource: textureView61},
    {binding: 66, resource: textureView71},
    {binding: 134, resource: textureView85},
    {binding: 8, resource: {buffer: buffer6, offset: 12800, size: 1504}},
    {binding: 72, resource: {buffer: buffer5, offset: 1280}},
    {binding: 189, resource: textureView82},
    {binding: 0, resource: textureView6},
    {binding: 495, resource: {buffer: buffer36, offset: 7936, size: 519}},
    {binding: 319, resource: externalTexture11},
    {binding: 156, resource: textureView15},
    {binding: 207, resource: textureView123},
    {binding: 268, resource: textureView76},
    {binding: 25, resource: {buffer: buffer79, offset: 3328, size: 2722}},
  ],
});
let buffer82 = device0.createBuffer({
  size: 28098,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder108 = device0.createCommandEncoder({});
let texture167 = device0.createTexture({
  size: [26, 20, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler64 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.27,
  maxAnisotropy: 20,
});
try {
renderPassEncoder21.setBindGroup(0, bindGroup25, new Uint32Array(5309), 300, 0);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let textureView142 = texture167.createView({
  label: '\u0c44\u6e0b\u6a6f\u38eb\u138e\u2c15\u4052\ufd0a\ub94f\u{1ffd5}\u03c5',
  dimension: '2d',
  format: 'r32float',
});
let texture168 = device0.createTexture({
  label: '\u034f\u9ea7\u4429\ua527\u4211\uecab\u0513\ubc3e\u0078\u1bfe\u{1f90d}',
  size: {width: 13, height: 10, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder10.setIndexBuffer(buffer47, 'uint16', 262, 987);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 408, new Int16Array(88), 7, 4);
} catch {}
let commandEncoder109 = device0.createCommandEncoder();
let sampler65 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 27.60,
  lodMaxClamp: 63.68,
  maxAnisotropy: 13,
});
try {
computePassEncoder85.setBindGroup(0, bindGroup47, new Uint32Array(204), 37, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup30);
} catch {}
try {
buffer82.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture155,
  mipLevel: 1,
  origin: {x: 0, y: 1, z: 10},
  aspect: 'all',
}, new Uint8Array(177).fill(174), /* required buffer size: 177 */
{offset: 15, bytesPerRow: 27, rowsPerImage: 6}, {width: 6, height: 0, depthOrArrayLayers: 2});
} catch {}
canvas2.width = 1859;
let imageData11 = new ImageData(8, 36);
let textureView143 = texture75.createView({});
let computePassEncoder89 = commandEncoder107.beginComputePass({});
try {
computePassEncoder41.setBindGroup(0, bindGroup38);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup10, new Uint32Array(1675), 851, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer66, 8_872);
} catch {}
try {
computePassEncoder89.pushDebugGroup('\u0c22');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler64}, {binding: 28, resource: textureView12}],
});
let renderPassEncoder22 = commandEncoder109.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  clearValue: { r: -698.0, g: 466.0, b: -597.9, a: 360.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet13,
});
let sampler66 = device0.createSampler({
  label: '\u53db\u{1ffb6}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 14.52,
  lodMaxClamp: 87.46,
});
try {
computePassEncoder76.setBindGroup(2, bindGroup27);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup39, []);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup6, new Uint32Array(772), 83, 0);
} catch {}
try {
computePassEncoder89.popDebugGroup();
} catch {}
let bindGroup56 = device0.createBindGroup({
  label: '\u{1f953}\u8544\u77bd\u0153\u0f79\u8568\u5dff\ud918\u{1fcea}\ud807',
  layout: bindGroupLayout4,
  entries: [
    {binding: 7, resource: textureView15},
    {binding: 112, resource: sampler62},
    {binding: 136, resource: textureView114},
    {binding: 29, resource: textureView41},
    {binding: 124, resource: textureView20},
  ],
});
let sampler67 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 14.68,
  lodMaxClamp: 53.62,
  maxAnisotropy: 20,
});
try {
computePassEncoder60.setBindGroup(0, bindGroup17, new Uint32Array(806), 246, 0);
} catch {}
try {
querySet11.destroy();
} catch {}
try {
commandEncoder108.copyBufferToBuffer(buffer18, 392, buffer13, 1452, 4032);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'srgb'});
} catch {}
document.body.append(canvas1);
let bindGroup57 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 134, resource: externalTexture14}, {binding: 49, resource: textureView100}],
});
let commandEncoder110 = device0.createCommandEncoder();
let computePassEncoder90 = commandEncoder108.beginComputePass({label: '\u0ee4\u8c4d\uf07d\uf0f5\u0a9b\ufe00'});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
});
try {
renderPassEncoder12.setBindGroup(1, bindGroup39, new Uint32Array(4335), 121, 0);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(185);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer8, 76, 1_618);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer47, 'uint32', 1_152, 251);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(5, buffer74, 304, 539);
} catch {}
try {
commandEncoder110.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2404 */
  offset: 2404,
  bytesPerRow: 5376,
  buffer: buffer22,
}, {
  texture: texture152,
  mipLevel: 1,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer60, 744, new DataView(new ArrayBuffer(14564)), 2727, 0);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
try {
  await promise11;
} catch {}
try {
adapter0.label = '\u2323\uc699\u{1f73c}';
} catch {}
let buffer83 = device0.createBuffer({
  label: '\u{1fc18}\u{1fa2f}\uf19e\u2d4e\ua932\u4541',
  size: 3772,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder111 = device0.createCommandEncoder();
let textureView144 = texture61.createView({baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder91 = commandEncoder111.beginComputePass({});
let renderBundle16 = renderBundleEncoder16.finish({});
document.body.append(canvas4);
offscreenCanvas0.width = 133;
try {
adapter0.label = '\u088c\u{1f7b3}';
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let renderPassEncoder23 = commandEncoder112.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -9.189, g: -979.3, b: 446.9, a: -96.51, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet7,
});
let sampler68 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMinClamp: 22.88,
  lodMaxClamp: 26.36,
});
try {
commandEncoder110.copyTextureToTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 7, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 90, y: 0, z: 3},
  aspect: 'all',
},
{width: 9, height: 2, depthOrArrayLayers: 4});
} catch {}
let commandEncoder113 = device0.createCommandEncoder({});
let computePassEncoder92 = commandEncoder110.beginComputePass({});
let renderPassEncoder24 = commandEncoder113.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  clearValue: { r: 497.9, g: 629.2, b: 709.3, a: 153.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet3,
});
try {
computePassEncoder29.setBindGroup(1, bindGroup32, new Uint32Array(793), 400, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup29);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup52, new Uint32Array(914), 157, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(102);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.setStencilReference(210);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(2, buffer22, 1_712);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let bindGroup58 = device0.createBindGroup({
  label: '\u6aad\u11d9\u{1f9f9}\u0425\u090b\ud40b',
  layout: bindGroupLayout15,
  entries: [{binding: 61, resource: textureView10}],
});
let commandEncoder114 = device0.createCommandEncoder();
let querySet14 = device0.createQuerySet({type: 'occlusion', count: 86});
let renderPassEncoder25 = commandEncoder114.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  clearValue: { r: 695.0, g: 799.3, b: 962.1, a: 898.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder51.setBindGroup(2, bindGroup50);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup13, new Uint32Array(2244), 334, 0);
} catch {}
try {
renderPassEncoder25.setViewport(26.91576892112239, 5.753449882690691, 3.394660069809568, 13.494615712059144, 0.19252839867882077, 0.2729628080278496);
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u649e');
} catch {}
let commandEncoder115 = device0.createCommandEncoder({});
let texture169 = device0.createTexture({
  label: '\u09a9\u{1f653}',
  size: {width: 161, height: 1, depthOrArrayLayers: 78},
  mipLevelCount: 5,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder93 = commandEncoder115.beginComputePass({});
let sampler69 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 16.08,
  lodMaxClamp: 51.31,
});
let externalTexture17 = device0.importExternalTexture({
  label: '\u62e7\u204f\uf8fc\u552f\u9f06\u1ae9\u9ade\udf49\ua31f\ubf81\u{1f993}',
  source: videoFrame1,
  colorSpace: 'srgb',
});
try {
computePassEncoder93.setBindGroup(2, bindGroup5);
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({label: '\u0120\u09ad\u8643\u00e5', bindGroupLayouts: []});
try {
renderPassEncoder16.setBindGroup(2, bindGroup40);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup29, new Uint32Array(716), 114, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let buffer84 = device0.createBuffer({
  size: 43398,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder116 = device0.createCommandEncoder({});
try {
computePassEncoder35.setBindGroup(2, bindGroup15);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup7, []);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer29, 5488, new DataView(new ArrayBuffer(3743)), 1245, 520);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(64).fill(66), /* required buffer size: 64 */
{offset: 64, bytesPerRow: 79}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 496,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 248,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 71,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 162,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
  ],
});
let texture170 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder94 = commandEncoder116.beginComputePass({label: '\u{1fff8}\u675b\u{1fc08}\uf789\u0803\u7c75\uafca'});
try {
computePassEncoder14.setBindGroup(1, bindGroup9, new Uint32Array(726), 16, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer61, 'uint32', 724, 6_211);
} catch {}
await gc();
let textureView145 = texture170.createView({format: 'rgba32uint', baseMipLevel: 0});
let texture171 = device0.createTexture({
  label: '\ua53a\ud558\u{1fb4f}\u1fad\u04b0\u07b0',
  size: [104, 80, 1],
  mipLevelCount: 1,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder15.setBindGroup(2, bindGroup48);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer74, 184, 299);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let imageData12 = new ImageData(40, 32);
let bindGroup59 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 49, resource: textureView109}, {binding: 134, resource: externalTexture6}],
});
let commandEncoder117 = device0.createCommandEncoder({label: '\u45fc\u0b91\u5288\u038d'});
let textureView146 = texture23.createView({dimension: '2d', baseArrayLayer: 3});
let computePassEncoder95 = commandEncoder117.beginComputePass({});
try {
renderPassEncoder3.setBindGroup(3, bindGroup15);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 2988, new Float32Array(1099), 326, 164);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup60 = device0.createBindGroup({
  label: '\u7e10\u{1f639}\u0d22\u327e\u{1f650}\u0b30\u049b\u0eab',
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView9},
    {binding: 285, resource: {buffer: buffer75, offset: 12544, size: 5645}},
  ],
});
let textureView147 = texture96.createView({baseArrayLayer: 18, arrayLayerCount: 1});
try {
renderPassEncoder14.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(285);
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer85: vec2i;

@group(0) @binding(38) var st6: texture_storage_3d<rg32float, write>;

@group(0) @binding(41) var<storage, read> buffer86: array<f32, 1>;

@group(0) @binding(107) var tex12: texture_1d<u32>;

@group(0) @binding(115) var tex13: texture_1d<i32>;

@group(0) @binding(245) var st7: texture_storage_3d<r32uint, read>;

@group(0) @binding(268) var tex14: texture_2d_array<u32>;

@group(0) @binding(296) var tex15: texture_2d<u32>;

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

struct VertexOutput4 {
  @builtin(position) f13: vec4f,
}

struct FragmentOutput1 {
  @location(0) f0: vec2u,
}

alias vec3b = vec3<bool>;

fn fn0(a0: ptr<private, vec2h>) -> T0 {
  var out: T0;
  out = T0(f16((*&buffer86)[0]));
  out.f0 = f16(extractBits(u32(unconst_u32(335)), u32(unconst_u32(31)), u32(unconst_u32(62))));
  let ptr32: ptr<storage, array<f32, 1>, read> = &(*&buffer86);
  var vf35: vec3f = trunc(vec3f(unconst_f32(-0.09414), unconst_f32(-0.05899), unconst_f32(0.03427)));
  let ptr33: ptr<storage, f32, read> = &(*&buffer86)[u32(unconst_u32(61))];
  let ptr34: ptr<storage, array<f32, 1>, read> = &(*&buffer86);
  (*a0) *= vec2h(countTrailingZeros(vec3u(unconst_u32(18), unconst_u32(145), unconst_u32(20))).zz);
  let ptr35: ptr<storage, f32, read> = &(*ptr32)[u32(unconst_u32(76))];
  let vf36: vec3u = countTrailingZeros(vec3u(unconst_u32(195), unconst_u32(139), unconst_u32(794)));
  let ptr36: ptr<storage, f32, read> = &(*ptr32)[0];
  let ptr37: ptr<storage, f32, read> = &(*ptr35);
  let ptr38: ptr<storage, f32, read> = &(*&buffer86)[0];
  let ptr39: ptr<storage, f32, read> = &(*&buffer86)[u32(unconst_u32(178))];
  let ptr40: ptr<storage, f32, read> = &(*ptr36);
  (*a0) -= bitcast<vec2h>((*&buffer86)[u32((*ptr34)[bitcast<vec3u>(trunc(vec3f(unconst_f32(-0.08444), unconst_f32(0.3649), unconst_f32(0.1426)))).g])]);
  (*a0) = atan(vec4h(unconst_f16(3166.7), unconst_f16(1966.5), unconst_f16(11619.5), unconst_f16(1541.4))).rr;
  var vf37: vec3u = vf36;
  let ptr41: ptr<storage, f32, read> = &(*ptr39);
  let ptr42: ptr<storage, f32, read> = &(*&buffer86)[0];
  let ptr43: ptr<storage, f32, read> = &(*&buffer86)[0];
  out = T0(f16((*ptr32)[u32(unconst_u32(243))]));
  vf35 = vec3f((*&buffer86)[0]);
  vf35 = vec3f((*&buffer86)[0]);
  return out;
}

fn fn1() -> T0 {
  var out: T0;
  let vf38: vec4f = unpack4x8snorm(u32(unconst_u32(26)));
  var vf39: u32 = pack4xU8Clamp(vec4u(unconst_u32(244), unconst_u32(109), unconst_u32(100), unconst_u32(124)));
  out.f0 *= f16((*&buffer86)[0]);
  vf39 >>= abs(vec2u(unconst_u32(19), unconst_u32(404))).g;
  vf39 = u32(asin(asin(vec4f(unconst_f32(0.08189), unconst_f32(-0.06246), unconst_f32(0.6298), unconst_f32(0.1469)))).w);
  let ptr44: ptr<storage, f32, read> = &buffer86[0];
  let ptr45: ptr<storage, f32, read> = &(*&buffer86)[0];
  out.f0 = f16((*&buffer86)[0]);
  out = T0(f16((*&buffer86)[0]));
  vf39 -= u32((*&buffer86)[pack4x8unorm(unpack4x8snorm(u32(unconst_u32(33))))]);
  out.f0 = vec2h(unpack2x16unorm(bitcast<vec2u>(insertBits(vec2i(unconst_i32(178), unconst_i32(-14)), vec2i(unconst_i32(32), unconst_i32(623)), u32(unconst_u32(518)), u32(unconst_u32(37)))).y))[1];
  let ptr46: ptr<storage, f32, read> = &(*&buffer86)[0];
  return out;
}

fn fn2() -> vec4h {
  var out: vec4h;
  textureStore(st6, vec3i(unconst_i32(-131), unconst_i32(82), unconst_i32(242)), vec4f(bitcast<vec4f>(buffer85.grrg)));
  textureStore(st6, vec3i(unconst_i32(416), unconst_i32(280), unconst_i32(218)), vec4f(vec4f(unconst_f32(0.4107), unconst_f32(0.01066), unconst_f32(0.01444), unconst_f32(0.05480))));
  fn1();
  var vf40: i32 = (*&buffer85)[u32(unconst_u32(165))];
  vf40 = i32((*&buffer86)[u32(unconst_u32(103))]);
  out += vec4h(f16(distance(bitcast<f32>(buffer85[u32(unconst_u32(636))]), f32(unconst_f32(0.05361)))));
  return out;
}

@vertex
fn vertex4() -> VertexOutput4 {
  var out: VertexOutput4;
  out.f13 = vec4f(buffer86[0]);
  out.f13 = vec4f(buffer86[u32(unconst_u32(119))]);
  out.f13 += vec4f((*&buffer86)[0]);
  var vf41 = fn1();
  out.f13 = vec4f(f32(vf41.f0));
  out.f13 *= vec4f(textureLoad(st7, vec3i(unconst_i32(113), unconst_i32(102), unconst_i32(4))));
  var vf42: u32 = dot4U8Packed(u32(unconst_u32(50)), u32(unconst_u32(311)));
  let ptr47: ptr<storage, f32, read> = &buffer86[u32(unconst_u32(84))];
  out.f13 *= vec4f((*ptr47));
  var vf43 = fn1();
  out = VertexOutput4(vec4f(f32(pack4xI8(vec4i(unconst_i32(125), unconst_i32(32), unconst_i32(28), unconst_i32(117))))));
  out.f13 = vec4f((*&buffer86)[u32(unconst_u32(32))]);
  fn1();
  out.f13 -= vec4f(f32(vf43.f0));
  vf43.f0 = f16(buffer86[0]);
  var vf44 = fn1();
  vf44 = T0(f16((*&buffer86)[0]));
  fn1();
  var vf45 = fn1();
  let ptr48: ptr<storage, f32, read> = &(*&buffer86)[u32((*&buffer86)[0])];
  fn1();
  vf45 = T0(f16(buffer86[0]));
  return out;
}

@fragment
fn fragment2() -> FragmentOutput1 {
  var out: FragmentOutput1;
  let vf46: bool = any(vec2<bool>(unconst_bool(true), unconst_bool(true)));
  fn2();
  fn2();
  out.f0 ^= vec2u(textureDimensions(tex12, 0i));
  out = FragmentOutput1(vec2u(u32((*&buffer86)[0])));
  var vf47: u32 = textureDimensions(tex12, 0i);
  textureStore(st6, vec3i(unconst_i32(255), unconst_i32(212), unconst_i32(200)), vec4f(vec4f(unconst_f32(0.3414), unconst_f32(0.3497), unconst_f32(0.3737), unconst_f32(0.1838))));
  let ptr49: ptr<storage, array<f32, 1>, read> = &(*&buffer86);
  out.f0 *= bitcast<vec2u>(textureLoad(tex13, i32(unconst_i32(37)), i32(unconst_i32(6))).xw);
  textureStore(st6, vec3i(bitcast<i32>(buffer86[0])), vec4f(vec4f(unconst_f32(0.3628), unconst_f32(0.09196), unconst_f32(0.1086), unconst_f32(0.05063))));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute1() {
  textureStore(st6, vec3i(unconst_i32(58), unconst_i32(27), unconst_i32(159)), vec4f(vec4f(unconst_f32(0.1603), unconst_f32(0.1443), unconst_f32(0.3845), unconst_f32(0.2110))));
  fn2();
  let vf48: vec2u = textureDimensions(tex14, i32(unconst_i32(87)));
  textureStore(st6, vec3i(unconst_i32(-119), unconst_i32(16), unconst_i32(31)), vec4f(vec4f(unconst_f32(0.2495), unconst_f32(0.2289), unconst_f32(0.02303), unconst_f32(0.1074))));
}`,
  sourceMap: {},
  hints: {},
});
let textureView148 = texture28.createView({dimension: '2d-array', aspect: 'depth-only'});
try {
computePassEncoder30.setBindGroup(3, bindGroup48, new Uint32Array(4180), 279, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer62, 8396, new Int16Array(14702), 1377, 3228);
} catch {}
let imageBitmap4 = await createImageBitmap(imageData10);
let imageData13 = new ImageData(20, 40);
let texture172 = device0.createTexture({
  label: '\u6a93\u0847\u5111\u0907\u0f62\u0459\u0a08',
  size: {width: 52},
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler70 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 34.26,
  lodMaxClamp: 68.87,
  maxAnisotropy: 10,
});
try {
computePassEncoder86.setBindGroup(1, bindGroup52);
} catch {}
try {
computePassEncoder42.setBindGroup(2, bindGroup10, new Uint32Array(755), 301, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle4]);
} catch {}
try {
texture76.label = '\u{1fa30}\ufd24\u{1f6d9}';
} catch {}
let textureView149 = texture10.createView({baseArrayLayer: 0});
let sampler71 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 88.67,
  maxAnisotropy: 19,
});
try {
computePassEncoder33.setBindGroup(0, bindGroup33);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
let commandEncoder118 = device0.createCommandEncoder({});
let texture173 = device0.createTexture({
  size: [27, 4, 179],
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder96 = commandEncoder118.beginComputePass();
try {
renderPassEncoder21.setBindGroup(0, bindGroup8);
} catch {}
document.body.append(canvas4);
await gc();
let bindGroup61 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 49, resource: textureView3}, {binding: 134, resource: externalTexture0}],
});
try {
renderPassEncoder21.setBindGroup(2, bindGroup42);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer24, 'uint32', 468, 10_718);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let bindGroup62 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 384, resource: externalTexture3},
    {binding: 20, resource: externalTexture12},
    {binding: 112, resource: textureView61},
    {binding: 118, resource: textureView100},
    {binding: 117, resource: {buffer: buffer9, offset: 512, size: 1974}},
    {binding: 232, resource: {buffer: buffer35, offset: 0}},
    {binding: 479, resource: externalTexture6},
    {binding: 68, resource: {buffer: buffer35, offset: 0}},
    {binding: 47, resource: sampler28},
    {binding: 36, resource: sampler27},
    {binding: 29, resource: sampler33},
    {binding: 697, resource: {buffer: buffer29, offset: 16128}},
    {binding: 348, resource: textureView10},
    {binding: 228, resource: {buffer: buffer22, offset: 0, size: 9440}},
    {binding: 62, resource: sampler55},
    {binding: 38, resource: sampler23},
    {binding: 95, resource: sampler24},
    {binding: 125, resource: textureView1},
    {binding: 54, resource: externalTexture14},
    {binding: 141, resource: textureView75},
    {binding: 330, resource: {buffer: buffer13, offset: 5376, size: 3782}},
    {binding: 8, resource: textureView61},
    {binding: 5, resource: textureView43},
    {binding: 2, resource: textureView76},
    {binding: 142, resource: textureView79},
    {binding: 162, resource: textureView86},
    {binding: 55, resource: {buffer: buffer33, offset: 1024, size: 1144}},
    {binding: 408, resource: textureView74},
    {binding: 67, resource: textureView141},
    {binding: 328, resource: textureView98},
    {binding: 49, resource: {buffer: buffer22, offset: 3072, size: 3132}},
    {binding: 195, resource: textureView145},
    {binding: 99, resource: {buffer: buffer62, offset: 768}},
    {binding: 135, resource: externalTexture16},
    {binding: 318, resource: {buffer: buffer62, offset: 2048}},
    {binding: 34, resource: sampler15},
    {binding: 61, resource: textureView5},
    {binding: 712, resource: {buffer: buffer62, offset: 6400}},
    {binding: 33, resource: textureView132},
    {binding: 209, resource: textureView65},
    {binding: 15, resource: textureView110},
    {binding: 161, resource: textureView149},
    {binding: 65, resource: textureView108},
    {binding: 216, resource: {buffer: buffer77, offset: 768, size: 2223}},
  ],
});
try {
computePassEncoder20.setBindGroup(2, bindGroup48);
} catch {}
try {
renderPassEncoder16.setBindGroup(1, bindGroup15, new Uint32Array(906), 55, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer84, 'uint16', 5_172, 234);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 11}
*/
{
  source: imageData1,
  origin: { x: 0, y: 29 },
  flipY: false,
}, {
  texture: texture151,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture174 = device0.createTexture({size: [27, 4, 66], format: 'rg16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder31.setBindGroup(0, bindGroup55, new Uint32Array(1736), 33, 0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer31, 'uint16', 150, 307);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer6, 8_840, 10_016);
} catch {}
let arrayBuffer6 = buffer0.getMappedRange(112, 8);
try {
buffer6.unmap();
} catch {}
document.body.append(canvas2);
let imageData14 = new ImageData(4, 48);
let textureView150 = texture33.createView({arrayLayerCount: 1});
try {
renderPassEncoder20.setBindGroup(0, bindGroup55);
} catch {}
try {
renderPassEncoder17.setBlendConstant({ r: 254.6, g: -427.1, b: 748.1, a: -364.8, });
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer18, 'uint16', 2_276);
} catch {}
try {
computePassEncoder33.insertDebugMarker('\u0cd8');
} catch {}
try {
globalThis.someLabel = sampler56.label;
} catch {}
let commandEncoder119 = device0.createCommandEncoder({});
let textureView151 = texture88.createView({mipLevelCount: 1});
let computePassEncoder97 = commandEncoder119.beginComputePass({label: '\u358e\u3054\ub00e\u6d5f\u3cb6\u8fac\ub379\u2b66\u8011'});
try {
renderPassEncoder17.executeBundles([renderBundle4, renderBundle1, renderBundle4]);
} catch {}
try {
renderPassEncoder3.setViewport(11.060229266820834, 8.105917331101423, 31.397279825958414, 7.731870224478501, 0.5710738946472101, 0.7073268335021052);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer2, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(208_625).fill(238), /* required buffer size: 208_625 */
{offset: 144, bytesPerRow: 553, rowsPerImage: 29}, {width: 34, height: 0, depthOrArrayLayers: 14});
} catch {}
try {
computePassEncoder29.setBindGroup(2, bindGroup58);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(3, buffer61, 1_040, 2_292);
} catch {}
document.body.prepend(canvas4);
let querySet15 = device0.createQuerySet({
  label: '\u02e7\u8924\u080c\u{1fbd6}\u081b\u{1fde2}\u{1f622}\u{1f68f}\ua1de\ua3b4',
  type: 'occlusion',
  count: 3124,
});
let sampler72 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 34.60,
  lodMaxClamp: 94.51,
});
try {
renderPassEncoder16.setIndexBuffer(buffer78, 'uint16', 2_002, 2_274);
} catch {}
document.body.append(canvas0);
try {
computePassEncoder88.end();
} catch {}
try {
commandEncoder105.copyBufferToBuffer(buffer57, 304, buffer25, 0, 1180);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
await gc();
let bindGroup63 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView11}]});
let texture175 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 156},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler73 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.83,
  lodMaxClamp: 99.84,
  maxAnisotropy: 18,
});
try {
renderPassEncoder7.executeBundles([renderBundle3, renderBundle6, renderBundle0, renderBundle1, renderBundle5]);
} catch {}
try {
renderPassEncoder0.setViewport(0.44896218343961003, 21.94472551520303, 41.138390058060345, 7.107995747407209, 0.14679378758440254, 0.934129601960245);
} catch {}
try {
commandEncoder105.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 368 */
  offset: 368,
  buffer: buffer44,
}, {
  texture: texture91,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder105.copyTextureToTexture({
  texture: texture172,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture135,
  mipLevel: 0,
  origin: {x: 124, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer37, 1412, new DataView(new ArrayBuffer(20294)), 7519, 6764);
} catch {}
let textureView152 = texture58.createView({dimension: 'cube-array', baseArrayLayer: 4, arrayLayerCount: 6});
let texture176 = device0.createTexture({
  label: '\u33ef\u0223\u{1fbbc}',
  size: {width: 161, height: 1, depthOrArrayLayers: 54},
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder98 = commandEncoder105.beginComputePass({});
try {
renderPassEncoder17.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer61);
} catch {}
let commandEncoder120 = device0.createCommandEncoder();
let computePassEncoder99 = commandEncoder120.beginComputePass({});
try {
computePassEncoder78.setBindGroup(3, bindGroup47, new Uint32Array(61), 15, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle7]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture102,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(367).fill(233), /* required buffer size: 367 */
{offset: 367}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let buffer87 = device0.createBuffer({size: 4179, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder121 = device0.createCommandEncoder({});
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 950});
let computePassEncoder100 = commandEncoder121.beginComputePass({});
try {
computePassEncoder13.setBindGroup(3, bindGroup23);
} catch {}
try {
computePassEncoder59.setBindGroup(2, bindGroup49, new Uint32Array(2824), 60, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup29);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
try {
  await promise12;
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup35, new Uint32Array(2485), 59, 0);
} catch {}
let videoFrame22 = new VideoFrame(imageBitmap0, {timestamp: 0});
let bindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let sampler74 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 74.14,
  lodMaxClamp: 97.58,
});
try {
renderPassEncoder17.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer84, 'uint16', 6_228, 6_559);
} catch {}
let arrayBuffer7 = buffer0.getMappedRange(152, 0);
await gc();
let bindGroup64 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 134, resource: externalTexture9}, {binding: 49, resource: textureView100}],
});
let texture177 = device0.createTexture({
  label: '\u{1fe69}\u{1fc0e}\u2a0f\u2dd8\u851c\u40c5\u{1fd76}\u9937\u0a5a\u438c',
  size: {width: 1290, height: 8, depthOrArrayLayers: 3},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let sampler75 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 86.38,
  lodMaxClamp: 86.87,
});
try {
renderPassEncoder17.setStencilReference(19);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer40, 'uint32', 656, 893);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, undefined, 258_975_246);
} catch {}
let bindGroup65 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 31, resource: textureView67}]});
let textureView153 = texture37.createView({});
try {
computePassEncoder56.setBindGroup(0, bindGroup57);
} catch {}
try {
computePassEncoder74.setBindGroup(1, bindGroup14, new Uint32Array(1948), 25, 0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer72, 'uint32', 4_920, 2_358);
} catch {}
let bindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {binding: 90, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 348,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let commandEncoder122 = device0.createCommandEncoder({});
let texture178 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 31},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView154 = texture92.createView({dimension: '2d', arrayLayerCount: 1});
let computePassEncoder101 = commandEncoder122.beginComputePass({});
try {
renderPassEncoder16.setBindGroup(1, bindGroup38, new Uint32Array(277), 47, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(516);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
computePassEncoder29.setBindGroup(2, bindGroup63);
} catch {}
try {
computePassEncoder68.setBindGroup(2, bindGroup32, new Uint32Array(403), 56, 0);
} catch {}
try {
renderPassEncoder23.setViewport(30.471075365935263, 27.87946337564196, 8.447835013238493, 9.213533438754563, 0.9082005131934006, 0.9960792705668047);
} catch {}
let buffer88 = device0.createBuffer({size: 10307, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView155 = texture71.createView({dimension: '2d-array', mipLevelCount: 1});
let sampler76 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 46.18,
  lodMaxClamp: 64.16,
  compare: 'not-equal',
});
try {
computePassEncoder97.setBindGroup(2, bindGroup47, []);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame20,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture167,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup66 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let texture179 = device0.createTexture({
  size: [13, 10, 1],
  mipLevelCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder45.setBindGroup(2, bindGroup40);
} catch {}
try {
computePassEncoder86.setBindGroup(3, bindGroup11, new Uint32Array(646), 65, 0);
} catch {}
try {
renderPassEncoder25.setBindGroup(2, bindGroup30);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle0, renderBundle5, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer84, 'uint32', 6_400, 609);
} catch {}
let arrayBuffer8 = buffer0.getMappedRange(120, 4);
let commandEncoder123 = device0.createCommandEncoder({});
let computePassEncoder102 = commandEncoder123.beginComputePass({label: '\u0f73\u0bdc\u024f\u{1f65e}\ueba6'});
try {
renderPassEncoder9.setBindGroup(0, bindGroup60, new Uint32Array(3131), 348, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer25, 'uint16', 10, 114);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup67 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 108, resource: {buffer: buffer1, offset: 3328, size: 93}},
    {binding: 8, resource: {buffer: buffer14, offset: 0, size: 752}},
    {binding: 319, resource: externalTexture16},
    {binding: 156, resource: textureView98},
    {binding: 58, resource: textureView61},
    {binding: 134, resource: textureView72},
    {binding: 72, resource: {buffer: buffer18, offset: 3072, size: 2604}},
    {binding: 0, resource: textureView137},
    {binding: 207, resource: textureView55},
    {binding: 25, resource: {buffer: buffer13, offset: 4096, size: 1230}},
    {binding: 268, resource: textureView149},
    {binding: 495, resource: {buffer: buffer64, offset: 0}},
    {binding: 66, resource: textureView71},
    {binding: 189, resource: textureView82},
  ],
});
let commandEncoder124 = device0.createCommandEncoder({});
let texture180 = device0.createTexture({
  size: [13],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder103 = commandEncoder124.beginComputePass({label: '\u03a8\u04a6\ue822\u{1f702}\u0703\u0f3b\u8e66\u767b\uf02a\u08be'});
try {
device0.queue.writeTexture({
  texture: texture93,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(159).fill(2), /* required buffer size: 159 */
{offset: 159, rowsPerImage: 74}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext6 = offscreenCanvas1.getContext('webgpu');
let videoFrame23 = new VideoFrame(videoFrame3, {timestamp: 0});
let textureView156 = texture110.createView({dimension: '2d-array', format: 'rg8sint', mipLevelCount: 1});
try {
computePassEncoder87.setBindGroup(3, bindGroup29);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
computePassEncoder92.insertDebugMarker('\u{1fb7e}');
} catch {}
try {
device0.queue.writeBuffer(buffer4, 100, new DataView(new ArrayBuffer(5005)), 1221, 160);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture177,
  mipLevel: 0,
  origin: {x: 97, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(286).fill(8), /* required buffer size: 286 */
{offset: 286, bytesPerRow: 184}, {width: 65, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'linear'} });
let bindGroup68 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 71, resource: {buffer: buffer81, offset: 3072}},
    {binding: 7, resource: {buffer: buffer29, offset: 512}},
  ],
});
let textureView157 = texture162.createView({label: '\u23b3\u3700\u00f4\u9c1b\u9777\u49c9', baseArrayLayer: 16, arrayLayerCount: 6});
try {
computePassEncoder38.setBindGroup(0, bindGroup32);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle4, renderBundle1, renderBundle7]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas3);
let texture181 = device0.createTexture({size: [322], dimension: '1d', format: 'rg16uint', usage: GPUTextureUsage.COPY_DST});
let sampler77 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 67.19,
  lodMaxClamp: 95.54,
});
try {
computePassEncoder56.setBindGroup(2, bindGroup11, new Uint32Array(898), 233, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, undefined, 360_231_638, 126_124_051);
} catch {}
try {
device0.queue.writeBuffer(buffer54, 36, new DataView(new ArrayBuffer(7790)), 3308, 784);
} catch {}
let texture182 = device0.createTexture({
  size: {width: 110},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView158 = texture77.createView({aspect: 'all', format: 'rgba16uint'});
let externalTexture18 = device0.importExternalTexture({source: videoFrame3});
try {
renderPassEncoder3.setBindGroup(0, bindGroup18);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle14, renderBundle1, renderBundle14]);
} catch {}
let bindGroup69 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 31, resource: textureView67}]});
let buffer89 = device0.createBuffer({
  size: 27717,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 775});
let texture183 = device0.createTexture({
  size: {width: 26},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder87.setBindGroup(3, bindGroup34);
} catch {}
try {
computePassEncoder0.end();
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup51);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer9, 'uint32', 904, 3_446);
} catch {}
try {
commandEncoder1.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 184 */
  offset: 184,
  buffer: buffer78,
}, {
  texture: texture66,
  mipLevel: 1,
  origin: {x: 65, y: 1, z: 0},
  aspect: 'all',
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder1.copyTextureToTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 35},
  aspect: 'all',
},
{
  texture: texture71,
  mipLevel: 0,
  origin: {x: 11, y: 1, z: 0},
  aspect: 'all',
},
{width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer90 = device0.createBuffer({size: 21233, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let textureView159 = texture16.createView({
  label: '\u099b\ua4f0\u8da9\u0578\ua1d5\ua305\ufbe2\u084f\u0c82\ub4e7\u{1f8c5}',
  baseMipLevel: 0,
  arrayLayerCount: 1,
});
let sampler78 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  lodMaxClamp: 31.61,
});
try {
computePassEncoder12.setBindGroup(3, bindGroup17, new Uint32Array(86), 47, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer9, 'uint16', 434, 966);
} catch {}
let texture184 = device0.createTexture({size: [27, 4, 153], mipLevelCount: 2, format: 'rgba16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let texture185 = gpuCanvasContext3.getCurrentTexture();
let computePassEncoder104 = commandEncoder1.beginComputePass({});
let externalTexture19 = device0.importExternalTexture({source: videoFrame12, colorSpace: 'display-p3'});
let commandEncoder125 = device0.createCommandEncoder();
let texture186 = device0.createTexture({
  size: [104],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
let texture187 = gpuCanvasContext4.getCurrentTexture();
try {
computePassEncoder11.setBindGroup(1, bindGroup61, new Uint32Array(6191), 1_395, 0);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup49, new Uint32Array(680), 404, 0);
} catch {}
try {
commandEncoder125.copyTextureToBuffer({
  texture: texture163,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3048 */
  offset: 3048,
  bytesPerRow: 13824,
  buffer: buffer77,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext5.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, alphaMode: 'premultiplied'});
} catch {}
let img0 = await imageWithData(46, 76, '#10101010', '#20202020');
let imageData15 = new ImageData(92, 52);
let commandEncoder126 = device0.createCommandEncoder({});
try {
renderPassEncoder19.setIndexBuffer(buffer1, 'uint16', 1_710, 4_592);
} catch {}
try {
  await buffer57.mapAsync(GPUMapMode.WRITE, 992, 32);
} catch {}
try {
device0.queue.writeBuffer(buffer52, 1496, new Float32Array(2337), 478, 332);
} catch {}
let commandEncoder127 = device0.createCommandEncoder({label: '\u{1fdb2}\u0c6d\u2b39\u{1fab2}\u{1fb0e}\u18f8'});
let textureView160 = texture115.createView({mipLevelCount: 1});
let computePassEncoder105 = commandEncoder125.beginComputePass({label: '\u0a44\ud7f6\u{1f9d8}\ub376\u7aa3'});
try {
renderPassEncoder0.setStencilReference(210);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer48, 'uint32', 48, 310);
} catch {}
try {
computePassEncoder49.pushDebugGroup('\u{1fabd}');
} catch {}
let textureView161 = texture65.createView({format: 'r32sint', mipLevelCount: 1, baseArrayLayer: 10, arrayLayerCount: 24});
try {
renderPassEncoder8.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle0]);
} catch {}
try {
computePassEncoder49.popDebugGroup();
} catch {}
document.body.prepend(canvas2);
let commandEncoder128 = device0.createCommandEncoder({});
let textureView162 = texture80.createView({mipLevelCount: 1, baseArrayLayer: 11, arrayLayerCount: 6});
let computePassEncoder106 = commandEncoder128.beginComputePass({});
try {
commandEncoder127.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 644 */
  offset: 644,
  buffer: buffer37,
}, {
  texture: texture152,
  mipLevel: 0,
  origin: {x: 0, y: 7, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder127.resolveQuerySet(querySet4, 6, 117, buffer28, 768);
} catch {}
try {
computePassEncoder101.pushDebugGroup('\u7237');
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); };
} catch {}
let textureView163 = texture86.createView({});
let computePassEncoder107 = commandEncoder127.beginComputePass({});
try {
computePassEncoder85.setBindGroup(0, bindGroup28);
} catch {}
try {
computePassEncoder2.setBindGroup(0, bindGroup21, new Uint32Array(6168), 240, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle4]);
} catch {}
try {
computePassEncoder101.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer64, 28, new DataView(new ArrayBuffer(6755)), 598, 228);
} catch {}
let bindGroup70 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 137, resource: {buffer: buffer2, offset: 512, size: 2039}},
    {binding: 19, resource: textureView1},
    {binding: 98, resource: {buffer: buffer25, offset: 0, size: 378}},
    {binding: 381, resource: {buffer: buffer17, offset: 1280, size: 3308}},
    {binding: 420, resource: sampler57},
    {binding: 153, resource: textureView108},
    {binding: 413, resource: textureView64},
    {binding: 44, resource: sampler22},
    {binding: 384, resource: {buffer: buffer81, offset: 256}},
    {binding: 140, resource: textureView141},
    {binding: 114, resource: textureView151},
    {binding: 201, resource: textureView161},
    {binding: 130, resource: {buffer: buffer19, offset: 256, size: 687}},
    {binding: 8, resource: sampler35},
    {binding: 191, resource: sampler3},
    {binding: 29, resource: textureView1},
    {binding: 51, resource: {buffer: buffer62, offset: 4352}},
    {binding: 87, resource: sampler55},
    {binding: 18, resource: sampler53},
    {binding: 56, resource: externalTexture16},
    {binding: 81, resource: textureView3},
    {binding: 133, resource: sampler46},
    {binding: 160, resource: sampler11},
    {binding: 0, resource: sampler52},
    {binding: 136, resource: textureView108},
    {binding: 20, resource: {buffer: buffer64, offset: 0, size: 242}},
    {binding: 388, resource: textureView109},
    {binding: 22, resource: {buffer: buffer61, offset: 2304, size: 3301}},
    {binding: 525, resource: {buffer: buffer24, offset: 8960, size: 638}},
    {binding: 128, resource: {buffer: buffer29, offset: 1024}},
    {binding: 21, resource: {buffer: buffer37, offset: 2048}},
    {binding: 193, resource: sampler59},
    {binding: 146, resource: {buffer: buffer6, offset: 6656, size: 1008}},
    {binding: 104, resource: textureView58},
    {binding: 64, resource: {buffer: buffer84, offset: 11008, size: 2600}},
    {binding: 154, resource: sampler62},
    {binding: 76, resource: {buffer: buffer56, offset: 512}},
    {binding: 66, resource: textureView107},
    {binding: 217, resource: textureView55},
    {binding: 107, resource: {buffer: buffer75, offset: 0, size: 3443}},
    {binding: 216, resource: sampler62},
    {binding: 67, resource: externalTexture7},
    {binding: 307, resource: {buffer: buffer75, offset: 4864, size: 2180}},
    {binding: 46, resource: textureView123},
    {binding: 158, resource: textureView30},
    {binding: 45, resource: sampler55},
    {binding: 134, resource: externalTexture6},
    {binding: 68, resource: sampler49},
    {binding: 119, resource: externalTexture6},
    {binding: 177, resource: sampler16},
    {binding: 280, resource: sampler33},
    {binding: 75, resource: textureView105},
    {binding: 35, resource: textureView1},
    {binding: 84, resource: externalTexture1},
    {binding: 309, resource: {buffer: buffer84, offset: 3072, size: 1700}},
    {binding: 90, resource: externalTexture3},
    {binding: 59, resource: textureView55},
    {binding: 65, resource: textureView61},
    {binding: 161, resource: {buffer: buffer89, offset: 3072, size: 2572}},
    {binding: 58, resource: textureView101},
    {binding: 61, resource: {buffer: buffer10, offset: 6144, size: 1341}},
    {binding: 132, resource: {buffer: buffer82, offset: 11264, size: 1088}},
  ],
});
let buffer91 = device0.createBuffer({
  label: '\udf3b\u0217\ue503\u0e29\udd57',
  size: 9736,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture188 = device0.createTexture({
  size: [1290, 8, 1],
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture189 = gpuCanvasContext3.getCurrentTexture();
let computePassEncoder108 = commandEncoder126.beginComputePass({});
try {
computePassEncoder73.setBindGroup(3, bindGroup48);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup59);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup27, new Uint32Array(89), 18, 0);
} catch {}
let textureView164 = texture25.createView({label: '\u03ff\u35df\u3787\u{1fec6}', aspect: 'all'});
try {
computePassEncoder50.setBindGroup(1, bindGroup21, new Uint32Array(4062), 1_926, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer54, 1_124);
} catch {}
let arrayBuffer9 = buffer0.getMappedRange(128, 0);
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let imageData16 = new ImageData(52, 20);
let buffer92 = device0.createBuffer({
  size: 15145,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder129 = device0.createCommandEncoder();
let textureView165 = texture40.createView({label: '\ub0f0\u2b89\u{1fbb0}\uc45f', baseArrayLayer: 0});
let computePassEncoder109 = commandEncoder129.beginComputePass({});
try {
computePassEncoder77.setBindGroup(3, bindGroup18);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup10, new Uint32Array(4587), 451, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer75, 'uint16', 1_374, 1_139);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(3_438).fill(74), /* required buffer size: 3_438 */
{offset: 238, bytesPerRow: 8, rowsPerImage: 50}, {width: 0, height: 0, depthOrArrayLayers: 9});
} catch {}
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte432', transfer: 'linear'} });
let sampler79 = device0.createSampler({
  label: '\u{1f75b}\u03b8\u0421\ubb53\uf3fe\u4622\u7dea\ucf4c\ue3cc\uda45\u07c7',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 1.613,
});
try {
computePassEncoder70.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup69);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup59, new Uint32Array(100), 21, 0);
} catch {}
try {
buffer56.unmap();
} catch {}
try {
adapter0.label = '\uc147\u{1ffa3}\uf3c3\u1e59\u0378\u51c6\u0177\u3932\u032a\u5e9f';
} catch {}
let bindGroup71 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 71, resource: {buffer: buffer42, offset: 256}},
    {binding: 7, resource: {buffer: buffer16, offset: 0, size: 2626}},
  ],
});
let commandEncoder130 = device0.createCommandEncoder({label: '\u0e1f\u0c27\u{1f7bb}\u{1fbcb}\u040d\u{1fbb1}\u{1ff8c}\u0da9\u8123'});
try {
computePassEncoder100.setBindGroup(1, bindGroup36);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup35, new Uint32Array(3668), 471, 0);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -303.9, g: -439.1, b: 398.9, a: 169.5, });
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer47, 'uint32', 764, 1_581);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer25, 0, 1_871);
} catch {}
try {
buffer74.unmap();
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 618 widthInBlocks: 309 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 474 */
  offset: 474,
  bytesPerRow: 10752,
  buffer: buffer56,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 156, y: 0, z: 0},
  aspect: 'all',
}, {width: 309, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture164,
  mipLevel: 0,
  origin: {x: 5, y: 8, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup72 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 148, resource: textureView149}, {binding: 389, resource: textureView55}],
});
let computePassEncoder110 = commandEncoder130.beginComputePass({});
try {
renderPassEncoder10.setBindGroup(1, bindGroup57, new Uint32Array(3061), 1_430, 0);
} catch {}
try {
renderPassEncoder8.setViewport(34.978270656069036, 38.742476414053485, 11.21189049020221, 0.3570675443587599, 0.7764414680573483, 0.940966190082316);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 272, new BigUint64Array(25106), 1394, 8);
} catch {}
let commandEncoder131 = device0.createCommandEncoder({});
let computePassEncoder111 = commandEncoder131.beginComputePass({});
let sampler80 = device0.createSampler({addressModeV: 'mirror-repeat', lodMinClamp: 72.57, lodMaxClamp: 87.86});
try {
  await buffer90.mapAsync(GPUMapMode.WRITE, 8328, 240);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let buffer93 = device0.createBuffer({size: 6764, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let textureView166 = texture26.createView({dimension: '3d'});
try {
renderPassEncoder0.setBindGroup(0, bindGroup13);
} catch {}
try {
renderPassEncoder4.executeBundles([]);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(1, buffer75, 5_000, 839);
} catch {}
try {
device0.queue.writeBuffer(buffer48, 524, new BigUint64Array(26190), 5171, 8);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
await gc();
let bindGroup73 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 112, resource: sampler33},
    {binding: 29, resource: textureView26},
    {binding: 136, resource: textureView114},
    {binding: 7, resource: textureView145},
    {binding: 124, resource: textureView42},
  ],
});
let commandEncoder132 = device0.createCommandEncoder({});
let texture190 = device0.createTexture({
  size: {width: 104},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView167 = texture115.createView({label: '\u7caf\ud246\ufcd1\u{1f7df}\u080c\u6b61\u14ef\u{1f84a}\u08d6\u3bb5', arrayLayerCount: 1});
let computePassEncoder112 = commandEncoder132.beginComputePass();
try {
computePassEncoder107.setBindGroup(1, bindGroup24, new Uint32Array(197), 15, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup39, new Uint32Array(103), 6, 0);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer25, 'uint16', 272, 150);
} catch {}
try {
renderPassEncoder18.insertDebugMarker('\u0eca');
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); };
} catch {}
let commandEncoder133 = device0.createCommandEncoder({});
let computePassEncoder113 = commandEncoder133.beginComputePass({});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true});
try {
computePassEncoder83.setBindGroup(2, bindGroup49);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 8504, new Float32Array(24049), 1841, 216);
} catch {}
let imageData17 = new ImageData(48, 16);
let bindGroup74 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 268, resource: textureView2},
    {binding: 296, resource: textureView15},
    {binding: 107, resource: textureView159},
    {binding: 38, resource: textureView43},
    {binding: 115, resource: textureView117},
    {binding: 245, resource: textureView121},
    {binding: 9, resource: {buffer: buffer2, offset: 3328, size: 462}},
    {binding: 41, resource: {buffer: buffer55, offset: 256, size: 4}},
  ],
});
let renderBundle17 = renderBundleEncoder17.finish();
let sampler81 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 65.77,
  maxAnisotropy: 20,
});
try {
computePassEncoder41.setBindGroup(2, bindGroup18, new Uint32Array(34), 2, 0);
} catch {}
try {
renderPassEncoder24.setBlendConstant({ r: 993.4, g: 897.2, b: 240.6, a: -163.0, });
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer43, 'uint32', 108, 954);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder14.insertDebugMarker('\u6b4e');
} catch {}
let commandEncoder134 = device0.createCommandEncoder({});
let sampler82 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 95.22,
  lodMaxClamp: 95.94,
  maxAnisotropy: 1,
});
try {
computePassEncoder29.setBindGroup(3, bindGroup61, new Uint32Array(482), 41, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle14, renderBundle0, renderBundle5]);
} catch {}
try {
buffer73.unmap();
} catch {}
try {
commandEncoder134.copyTextureToBuffer({
  texture: texture100,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 18536 */
  offset: 1608,
  bytesPerRow: 5632,
  rowsPerImage: 97,
  buffer: buffer6,
}, {width: 8, height: 4, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture116,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(104).fill(31), /* required buffer size: 104 */
{offset: 104, rowsPerImage: 12}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 445});
let texture191 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView168 = texture173.createView({dimension: '2d', baseArrayLayer: 6});
try {
renderPassEncoder18.setBindGroup(2, bindGroup30, new Uint32Array(1349), 412, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer84, 'uint32', 2_220, 17_955);
} catch {}
try {
commandEncoder134.copyBufferToBuffer(buffer22, 2028, buffer28, 2636, 44);
} catch {}
try {
commandEncoder134.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1954 */
  offset: 1954,
  buffer: buffer62,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder135 = device0.createCommandEncoder({});
let renderPassEncoder26 = commandEncoder134.beginRenderPass({
  colorAttachments: [{
  view: textureView104,
  depthSlice: 205,
  clearValue: { r: 310.6, g: 452.9, b: -106.2, a: -295.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder15.setBindGroup(2, bindGroup63);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer43, 'uint32', 704, 43);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture86,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(276).fill(213), /* required buffer size: 276 */
{offset: 276}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture192 = device0.createTexture({
  label: '\u5e4a\u{1fed6}\ufbe7\u333b\u0056\u03bb\u6d6d\u5777\u0a8e',
  size: {width: 32, height: 32, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder114 = commandEncoder135.beginComputePass();
try {
renderPassEncoder23.setViewport(47.72498609448167, 38.31427142091263, 2.4670097901454877, 0.8429793569648709, 0.7066315854286314, 0.9811230098236783);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer48, 'uint16', 236, 323);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
await gc();
let bindGroup75 = device0.createBindGroup({
  label: '\uc8bc\u8d51\u1ff5\u059a\u{1feba}\u4fc5\u8d3e\u35ee\u4dd5\u7a41',
  layout: bindGroupLayout5,
  entries: [
    {binding: 41, resource: {buffer: buffer14, offset: 256, size: 216}},
    {binding: 296, resource: textureView12},
    {binding: 107, resource: textureView159},
    {binding: 9, resource: {buffer: buffer91, offset: 0}},
    {binding: 38, resource: textureView38},
    {binding: 115, resource: textureView37},
    {binding: 268, resource: textureView7},
    {binding: 245, resource: textureView33},
  ],
});
let buffer94 = device0.createBuffer({
  size: 3380,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder136 = device0.createCommandEncoder();
let texture193 = device0.createTexture({
  label: '\ue8c8\ued8f\u05d6',
  size: [27, 4, 21],
  mipLevelCount: 3,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder115 = commandEncoder136.beginComputePass({});
let bindGroup76 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 49, resource: textureView3}, {binding: 134, resource: externalTexture19}],
});
let texture194 = device0.createTexture({size: {width: 104}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder78.setBindGroup(0, bindGroup49);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(3, buffer91, 2_160, 1_773);
} catch {}
try {
  await promise13;
} catch {}
let bindGroup77 = device0.createBindGroup({
  label: '\u0346\ue218\u{1fd71}\u{1faff}\u6d19\u0c40\u0b88\uc6a3\u7bb4\u061c',
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler20}, {binding: 28, resource: textureView15}],
});
let texture195 = device0.createTexture({
  size: {width: 27},
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder24.setBindGroup(3, bindGroup56, new Uint32Array(1977), 366, 0);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup40, []);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup64, new Uint32Array(511), 14, 0);
} catch {}
let commandEncoder137 = device0.createCommandEncoder({});
let textureView169 = texture53.createView({});
let computePassEncoder116 = commandEncoder137.beginComputePass({});
try {
computePassEncoder14.setBindGroup(0, bindGroup4, new Uint32Array(821), 390, 0);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle17, renderBundle0, renderBundle4]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 34},
  aspect: 'all',
}, new Uint8Array(40_474).fill(177), /* required buffer size: 40_474 */
{offset: 82, bytesPerRow: 36, rowsPerImage: 22}, {width: 9, height: 0, depthOrArrayLayers: 52});
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [
    {binding: 206, resource: textureView106},
    {binding: 230, resource: textureView76},
    {binding: 196, resource: sampler78},
    {binding: 74, resource: textureView141},
    {binding: 220, resource: textureView109},
    {binding: 380, resource: textureView62},
    {binding: 119, resource: textureView7},
    {binding: 289, resource: textureView87},
  ],
});
let commandEncoder138 = device0.createCommandEncoder();
let computePassEncoder117 = commandEncoder138.beginComputePass({});
try {
renderPassEncoder21.setBindGroup(2, bindGroup55);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 25},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder139 = device0.createCommandEncoder({});
let computePassEncoder118 = commandEncoder139.beginComputePass();
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4});
try {
renderPassEncoder3.setIndexBuffer(buffer16, 'uint32', 7_984, 109);
} catch {}
try {
renderBundleEncoder18.setBindGroup(2, bindGroup33, new Uint32Array(1081), 300, 0);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(2, buffer24, 0);
} catch {}
let arrayBuffer10 = buffer0.getMappedRange(88, 0);
let buffer95 = device0.createBuffer({
  size: 24079,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder15.setBindGroup(0, bindGroup20, new Uint32Array(1886), 13, 0);
} catch {}
try {
renderBundleEncoder18.setBindGroup(0, bindGroup55);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer84, 'uint16', 7_708, 7_354);
} catch {}
let buffer96 = device0.createBuffer({
  label: '\u0db5\u69d3\u751d\u05cd\u{1fdfb}\uf47b\u5277',
  size: 992,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: false,
});
let querySet19 = device0.createQuerySet({type: 'occlusion', count: 602});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: false});
try {
computePassEncoder20.setBindGroup(0, bindGroup77);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup64, new Uint32Array(1286), 56, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer87, 'uint16', 396, 653);
} catch {}
let textureView170 = texture42.createView({dimension: '2d-array'});
try {
computePassEncoder25.pushDebugGroup('\uee51');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture69,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(4_594).fill(107), /* required buffer size: 4_594 */
{offset: 282, bytesPerRow: 11, rowsPerImage: 56}, {width: 1, height: 0, depthOrArrayLayers: 8});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 15}
*/
{
  source: videoFrame15,
  origin: { x: 2, y: 1 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 29, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); };
} catch {}
let renderBundle18 = renderBundleEncoder19.finish({label: '\u5046\u0154\u{1f8a7}\uaf43\u00f3\u5bf1\u{1fd8f}\u9a75'});
try {
device0.queue.writeTexture({
  texture: texture91,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(48).fill(51), /* required buffer size: 48 */
{offset: 48, bytesPerRow: 81}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData18 = new ImageData(96, 16);
let textureView171 = texture120.createView({mipLevelCount: 1, arrayLayerCount: 3});
let renderBundle19 = renderBundleEncoder18.finish({});
try {
computePassEncoder37.setBindGroup(1, bindGroup25);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer82, 'uint16', 4_996, 629);
} catch {}
let bindGroup79 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 71, resource: {buffer: buffer52, offset: 768, size: 2836}},
    {binding: 7, resource: {buffer: buffer82, offset: 512, size: 4731}},
  ],
});
let sampler83 = device0.createSampler({
  label: '\u13fe\u{1f915}\ue2b3\u7abf\u9c8d\u7795\u081a\u71d1\u06e0\u{1fb43}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 24.28,
  lodMaxClamp: 68.99,
});
document.body.append(canvas0);
let bindGroup80 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler11}, {binding: 28, resource: textureView145}],
});
try {
computePassEncoder84.setBindGroup(0, bindGroup23);
} catch {}
try {
computePassEncoder44.setBindGroup(0, bindGroup9, new Uint32Array(1841), 657, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup57);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer20);
} catch {}
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'unspecified'} });
let bindGroup81 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 293, resource: textureView110}]});
let commandEncoder140 = device0.createCommandEncoder({});
let computePassEncoder119 = commandEncoder140.beginComputePass({});
let promise14 = device0.queue.onSubmittedWorkDone();
let offscreenCanvas2 = new OffscreenCanvas(30, 64);
let buffer97 = device0.createBuffer({
  label: '\u0621\u97f4\u0cc5\u40db\u{1f84c}\ub267\u2bb3\u040a\u9db9\u{1f61d}',
  size: 6843,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler84 = device0.createSampler({
  label: '\u{1f74b}\ua1fc\u139b',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 29.51,
  maxAnisotropy: 16,
});
try {
computePassEncoder96.setBindGroup(3, bindGroup9, new Uint32Array(6830), 394, 0);
} catch {}
let bindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 27,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 259,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder141 = device0.createCommandEncoder({});
let texture196 = device0.createTexture({
  size: [52, 40, 1],
  sampleCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView172 = texture21.createView({
  label: '\u83c9\u04ef\u0c0b\ub2e1\uec3f\u9088\u{1f83c}\u05fc\u{1f847}',
  baseArrayLayer: 11,
  arrayLayerCount: 5,
});
try {
renderPassEncoder0.setVertexBuffer(1, buffer72);
} catch {}
try {
buffer16.unmap();
} catch {}
let querySet20 = device0.createQuerySet({type: 'occlusion', count: 205});
let textureView173 = texture192.createView({baseMipLevel: 0});
try {
computePassEncoder44.setBindGroup(3, bindGroup67, new Uint32Array(1818), 826, 0);
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
try {
computePassEncoder114.setBindGroup(3, bindGroup81);
} catch {}
try {
computePassEncoder20.setBindGroup(1, bindGroup79, new Uint32Array(1228), 305, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup29, new Uint32Array(4013), 86, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer8, 'uint32', 3_072, 71);
} catch {}
let arrayBuffer11 = buffer57.getMappedRange(992, 0);
try {
commandEncoder141.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3304 */
  offset: 3304,
  bytesPerRow: 4096,
  buffer: buffer10,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 11},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder141.copyTextureToBuffer({
  texture: texture135,
  mipLevel: 0,
  origin: {x: 75, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2756 widthInBlocks: 689 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 676 */
  offset: 676,
  buffer: buffer54,
}, {width: 689, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
let commandEncoder142 = device0.createCommandEncoder({label: '\u8401\u{1ff57}\u02ec\u7acd\u501b\u0e3e\u{1ff1a}\u5c3e'});
let computePassEncoder120 = commandEncoder142.beginComputePass();
let externalTexture20 = device0.importExternalTexture({source: videoFrame26});
try {
renderPassEncoder16.setBindGroup(1, bindGroup14);
} catch {}
try {
commandEncoder141.copyTextureToBuffer({
  texture: texture177,
  mipLevel: 0,
  origin: {x: 374, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 96 widthInBlocks: 48 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 22 */
  offset: 22,
  bytesPerRow: 7168,
  buffer: buffer14,
}, {width: 48, height: 5, depthOrArrayLayers: 0});
} catch {}
await gc();
let commandEncoder143 = device0.createCommandEncoder({label: '\u{1f60b}\u{1fec9}\u0369\u{1fc52}\u0553\u096d'});
let computePassEncoder121 = commandEncoder141.beginComputePass();
try {
computePassEncoder30.setBindGroup(0, bindGroup42, new Uint32Array(2262), 97, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup26);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup32, new Uint32Array(983), 51, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle4, renderBundle0]);
} catch {}
try {
renderPassEncoder17.setViewport(34.156357781261846, 30.27961443540464, 1.5447981594082492, 8.571996227221433, 0.38345087603689165, 0.6310048433436946);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(1, buffer66);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder143.copyBufferToTexture({
  /* bytesInLastRow: 1140 widthInBlocks: 285 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2356 */
  offset: 2356,
  buffer: buffer53,
}, {
  texture: texture135,
  mipLevel: 0,
  origin: {x: 242, y: 0, z: 0},
  aspect: 'all',
}, {width: 285, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder25.popDebugGroup();
} catch {}
let buffer98 = device0.createBuffer({size: 8794, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder144 = device0.createCommandEncoder({label: '\u{1fd17}\u587a'});
let textureView174 = texture63.createView({dimension: '2d', baseArrayLayer: 34});
let renderPassEncoder27 = commandEncoder144.beginRenderPass({
  label: '\u80f6\u{1ffc1}\u81df\ud283\u{1f9e8}\ue95d\udc0b\u{1fb68}',
  colorAttachments: [{
  view: textureView104,
  depthSlice: 201,
  clearValue: { r: 199.2, g: -0.6052, b: -875.1, a: -869.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 68138375,
});
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(407).fill(159), /* required buffer size: 407 */
{offset: 407, rowsPerImage: 3}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer99 = device0.createBuffer({
  label: '\u03e7\udd9c\u0c4d\u{1fdcc}\uf221\u{1fb33}\u{1f773}\u0ab4\u{1f7ac}',
  size: 1728,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder145 = device0.createCommandEncoder({});
let computePassEncoder122 = commandEncoder145.beginComputePass();
try {
renderPassEncoder13.setBindGroup(3, bindGroup9, new Uint32Array(4575), 96, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer79);
} catch {}
let gpuCanvasContext7 = offscreenCanvas2.getContext('webgpu');
let buffer100 = device0.createBuffer({
  size: 11224,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder146 = device0.createCommandEncoder({});
let texture197 = device0.createTexture({
  size: [52],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder123 = commandEncoder146.beginComputePass({});
let renderPassEncoder28 = commandEncoder143.beginRenderPass({colorAttachments: [{view: textureView15, loadOp: 'clear', storeOp: 'store'}]});
try {
device0.queue.writeBuffer(buffer64, 60, new Int16Array(7955), 877, 4);
} catch {}
try {
computePassEncoder72.setBindGroup(2, bindGroup13, new Uint32Array(308), 34, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(199);
} catch {}
try {
renderPassEncoder17.executeBundles([]);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer54, 0, 1_354);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 984, new Float32Array(35553), 1149, 72);
} catch {}
let commandEncoder147 = device0.createCommandEncoder({});
let computePassEncoder124 = commandEncoder147.beginComputePass();
try {
computePassEncoder111.setBindGroup(0, bindGroup57, new Uint32Array(128), 127, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer79, 128, 6_570);
} catch {}
let renderBundleEncoder20 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
});
let renderBundle20 = renderBundleEncoder20.finish({});
try {
renderPassEncoder2.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle18]);
} catch {}
try {
renderPassEncoder25.pushDebugGroup('\u0c98');
} catch {}
let texture198 = device0.createTexture({
  size: [161, 1, 29],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture199 = device0.createTexture({size: [13, 10, 26], format: 'rg16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let sampler85 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 37.46,
  lodMaxClamp: 79.06,
  compare: 'equal',
  maxAnisotropy: 14,
});
try {
computePassEncoder54.setBindGroup(1, bindGroup59, new Uint32Array(189), 7, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
renderPassEncoder25.popDebugGroup();
} catch {}
await gc();
let commandEncoder148 = device0.createCommandEncoder({});
let texture200 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 16},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView175 = texture167.createView({label: '\u32b1\u8aad\u3673\u6672\u5f8c\uc3d6\u4099\u3b2b\ufb00\u{1ff25}', dimension: '2d-array'});
let computePassEncoder125 = commandEncoder148.beginComputePass({});
try {
renderPassEncoder8.setBindGroup(0, bindGroup14, new Uint32Array(709), 155, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer75, 'uint16', 420, 521);
} catch {}
let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout1, bindGroupLayout10]});
let commandEncoder149 = device0.createCommandEncoder({});
try {
computePassEncoder34.setBindGroup(2, bindGroup52, []);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer79, 'uint32', 3_532, 2_343);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer99);
} catch {}
let bindGroup82 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 8, resource: {buffer: buffer37, offset: 3584, size: 5464}},
    {binding: 25, resource: {buffer: buffer10, offset: 768, size: 2404}},
    {binding: 319, resource: externalTexture17},
    {binding: 58, resource: textureView61},
    {binding: 108, resource: {buffer: buffer64, offset: 512, size: 130}},
    {binding: 207, resource: textureView123},
    {binding: 72, resource: {buffer: buffer5, offset: 768}},
    {binding: 0, resource: textureView6},
    {binding: 268, resource: textureView128},
    {binding: 495, resource: {buffer: buffer25, offset: 256, size: 1052}},
    {binding: 66, resource: textureView71},
    {binding: 189, resource: textureView155},
    {binding: 156, resource: textureView145},
    {binding: 134, resource: textureView72},
  ],
});
let sampler86 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 85.23,
  compare: 'not-equal',
});
try {
computePassEncoder73.end();
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); };
} catch {}
let buffer101 = device0.createBuffer({size: 3132, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder150 = device0.createCommandEncoder({});
let texture201 = device0.createTexture({size: [322, 2, 31], dimension: '3d', format: 'rgba16float', usage: GPUTextureUsage.COPY_DST});
let textureView176 = texture36.createView({format: 'rg32float'});
let sampler87 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 75.13,
  lodMaxClamp: 82.78,
  maxAnisotropy: 4,
});
try {
buffer78.unmap();
} catch {}
try {
commandEncoder88.copyBufferToTexture({
  /* bytesInLastRow: 84 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2044 */
  offset: 2044,
  bytesPerRow: 39936,
  buffer: buffer37,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup83 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 98, resource: {buffer: buffer100, offset: 256}},
    {binding: 61, resource: {buffer: buffer62, offset: 11264}},
    {binding: 75, resource: textureView105},
    {binding: 68, resource: sampler19},
    {binding: 19, resource: textureView108},
    {binding: 107, resource: {buffer: buffer79, offset: 4608, size: 5998}},
    {binding: 136, resource: textureView109},
    {binding: 76, resource: {buffer: buffer1, offset: 2560, size: 8272}},
    {binding: 217, resource: textureView123},
    {binding: 22, resource: {buffer: buffer97, offset: 3584, size: 535}},
    {binding: 384, resource: {buffer: buffer84, offset: 16128, size: 1228}},
    {binding: 309, resource: {buffer: buffer49, offset: 0}},
    {binding: 18, resource: sampler85},
    {binding: 177, resource: sampler14},
    {binding: 420, resource: sampler18},
    {binding: 35, resource: textureView1},
    {binding: 90, resource: externalTexture7},
    {binding: 84, resource: externalTexture5},
    {binding: 134, resource: externalTexture14},
    {binding: 161, resource: {buffer: buffer7, offset: 0}},
    {binding: 137, resource: {buffer: buffer62, offset: 2048}},
    {binding: 413, resource: textureView64},
    {binding: 81, resource: textureView1},
    {binding: 193, resource: sampler2},
    {binding: 119, resource: externalTexture7},
    {binding: 191, resource: sampler51},
    {binding: 66, resource: textureView107},
    {binding: 46, resource: textureView55},
    {binding: 8, resource: sampler31},
    {binding: 133, resource: sampler66},
    {binding: 201, resource: textureView147},
    {binding: 154, resource: sampler63},
    {binding: 216, resource: sampler33},
    {binding: 153, resource: textureView100},
    {binding: 51, resource: {buffer: buffer5, offset: 512}},
    {binding: 45, resource: sampler63},
    {binding: 87, resource: sampler33},
    {binding: 307, resource: {buffer: buffer52, offset: 0, size: 2107}},
    {binding: 59, resource: textureView154},
    {binding: 21, resource: {buffer: buffer29, offset: 256}},
    {binding: 130, resource: {buffer: buffer75, offset: 19712, size: 571}},
    {binding: 388, resource: textureView110},
    {binding: 29, resource: textureView1},
    {binding: 65, resource: textureView61},
    {binding: 132, resource: {buffer: buffer6, offset: 768, size: 1676}},
    {binding: 58, resource: textureView60},
    {binding: 158, resource: textureView73},
    {binding: 280, resource: sampler7},
    {binding: 160, resource: sampler4},
    {binding: 128, resource: {buffer: buffer30, offset: 0, size: 3009}},
    {binding: 20, resource: {buffer: buffer9, offset: 5120, size: 379}},
    {binding: 114, resource: textureView154},
    {binding: 381, resource: {buffer: buffer49, offset: 256}},
    {binding: 525, resource: {buffer: buffer17, offset: 1280, size: 4388}},
    {binding: 140, resource: textureView76},
    {binding: 64, resource: {buffer: buffer77, offset: 256, size: 1724}},
    {binding: 0, resource: sampler19},
    {binding: 44, resource: sampler86},
    {binding: 146, resource: {buffer: buffer8, offset: 0}},
    {binding: 67, resource: externalTexture8},
    {binding: 104, resource: textureView58},
    {binding: 56, resource: externalTexture4},
  ],
});
let commandEncoder151 = device0.createCommandEncoder({});
let texture202 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder77.setBindGroup(3, bindGroup19);
} catch {}
let bindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 219,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'float', multisampled: false },
    },
  ],
});
let commandEncoder152 = device0.createCommandEncoder();
let textureView177 = texture188.createView({dimension: '2d-array', baseArrayLayer: 0});
let computePassEncoder126 = commandEncoder149.beginComputePass({});
try {
computePassEncoder42.setBindGroup(0, bindGroup56);
} catch {}
try {
computePassEncoder108.setBindGroup(0, bindGroup50, new Uint32Array(1352), 218, 0);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle17]);
} catch {}
let commandEncoder153 = device0.createCommandEncoder({});
let texture203 = device0.createTexture({size: [26, 20, 1], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
let textureView178 = texture81.createView({label: '\u9e99\ub3ed\u00ff\ud64d\u0cef\u1c8f\u0093\u{1fbf5}\ud840\u0a70\u{1ff17}'});
let renderPassEncoder29 = commandEncoder151.beginRenderPass({
  colorAttachments: [{
  view: textureView144,
  clearValue: { r: 211.4, g: 373.6, b: -441.3, a: -188.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder2.executeBundles([renderBundle2, renderBundle7, renderBundle0]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandBuffer2 = commandEncoder88.finish();
let renderBundleEncoder21 = device0.createRenderBundleEncoder({
  label: '\u72ca\u9602\uc8e3\u{1f73a}\u549d',
  colorFormats: ['rgb10a2uint'],
  sampleCount: 4,
  stencilReadOnly: true,
});
let renderBundle21 = renderBundleEncoder21.finish();
try {
commandEncoder150.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 912 */
  offset: 912,
  bytesPerRow: 40960,
  rowsPerImage: 1338,
  buffer: buffer62,
}, {
  texture: texture144,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
}, {width: 4, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: imageData17,
  origin: { x: 3, y: 0 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 6, height: 4, depthOrArrayLayers: 0});
} catch {}
let texture204 = device0.createTexture({
  label: '\u54b2\ub969\u01ac\u0b37\u0ebe\u{1fbf5}',
  size: {width: 27, height: 4, depthOrArrayLayers: 41},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler88 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 41.89,
  lodMaxClamp: 76.09,
  maxAnisotropy: 13,
});
try {
computePassEncoder109.setBindGroup(2, bindGroup67, new Uint32Array(1115), 86, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer75, 18_324);
} catch {}
let texture205 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView179 = texture46.createView({});
try {
renderPassEncoder21.setBindGroup(1, bindGroup76);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup67, new Uint32Array(1628), 282, 0);
} catch {}
try {
commandEncoder150.copyTextureToBuffer({
  texture: texture132,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 230 */
  offset: 230,
  buffer: buffer4,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture182,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(68).fill(177), /* required buffer size: 68 */
{offset: 68, rowsPerImage: 39}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: imageData18,
  origin: { x: 19, y: 10 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 40},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup84 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [
    {binding: 196, resource: sampler64},
    {binding: 289, resource: textureView87},
    {binding: 119, resource: textureView2},
    {binding: 220, resource: textureView110},
    {binding: 74, resource: textureView149},
    {binding: 380, resource: textureView179},
    {binding: 230, resource: textureView3},
    {binding: 206, resource: textureView106},
  ],
});
let textureView180 = texture178.createView({mipLevelCount: 1});
let computePassEncoder127 = commandEncoder150.beginComputePass({});
let renderPassEncoder30 = commandEncoder153.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: 640.1, g: 146.4, b: -799.1, a: -734.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet9,
});
let sampler89 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 64.36,
  lodMaxClamp: 69.44,
  maxAnisotropy: 14,
});
try {
computePassEncoder49.setBindGroup(2, bindGroup49, new Uint32Array(2879), 87, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup50, new Uint32Array(863), 54, 0);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle7, renderBundle18, renderBundle2, renderBundle2]);
} catch {}
try {
renderPassEncoder9.setStencilReference(432);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer42, 0, 1_043);
} catch {}
try {
commandEncoder152.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1566 */
  offset: 1566,
  bytesPerRow: 512,
  buffer: buffer53,
}, {
  texture: texture133,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder154 = device0.createCommandEncoder();
let textureView181 = texture165.createView({label: '\u072e\ua669\u0652', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5});
let textureView182 = texture132.createView({label: '\u99c5\u8f5a\u3a55\ufffc', dimension: '2d'});
try {
buffer15.unmap();
} catch {}
try {
commandEncoder154.clearBuffer(buffer6, 3172, 2820);
} catch {}
let bindGroup85 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let commandEncoder155 = device0.createCommandEncoder();
let textureView183 = texture193.createView({mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 2});
try {
computePassEncoder60.setBindGroup(1, bindGroup30, new Uint32Array(398), 31, 0);
} catch {}
let commandEncoder156 = device0.createCommandEncoder();
try {
computePassEncoder50.setBindGroup(0, bindGroup18, new Uint32Array(365), 18, 0);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(2, undefined, 0);
} catch {}
try {
commandEncoder154.copyTextureToTexture({
  texture: texture5,
  mipLevel: 3,
  origin: {x: 24, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture13,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 50},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(440_413).fill(3), /* required buffer size: 440_413 */
{offset: 73, bytesPerRow: 1790, rowsPerImage: 123}, {width: 106, height: 0, depthOrArrayLayers: 3});
} catch {}
let pipeline0 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout6,
  multisample: {count: 4, mask: 0xbb25746},
  fragment: {
  module: shaderModule2,
  targets: [{format: 'rg16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r16float'}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL}, {format: 'bgra8unorm-srgb'}, {
  format: 'rgba16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'dst'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}],
},
  vertex: {module: shaderModule3, buffers: []},
  primitive: {topology: 'line-list', frontFace: 'ccw', unclippedDepth: false},
});
let commandEncoder157 = device0.createCommandEncoder({label: '\u000b\u0195\u192e\u04f6\u4229\u26b3\u060d\u7104\u18ef\u0617\u0b57'});
let texture206 = device0.createTexture({
  size: {width: 110},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder128 = commandEncoder155.beginComputePass();
let renderPassEncoder31 = commandEncoder157.beginRenderPass({colorAttachments: [{view: textureView94, loadOp: 'load', storeOp: 'store'}]});
try {
renderPassEncoder0.setScissorRect(2, 0, 11, 2);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer30, 152);
} catch {}
try {
commandEncoder152.copyBufferToBuffer(buffer49, 1588, buffer93, 2240, 532);
} catch {}
try {
commandEncoder154.copyBufferToTexture({
  /* bytesInLastRow: 1256 widthInBlocks: 314 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 184 */
  offset: 184,
  bytesPerRow: 12032,
  buffer: buffer66,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
}, {width: 314, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise15;
} catch {}
let texture207 = device0.createTexture({
  size: [55, 8, 81],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder129 = commandEncoder152.beginComputePass({});
try {
renderPassEncoder9.setBindGroup(3, bindGroup55);
} catch {}
try {
device0.queue.writeBuffer(buffer37, 5384, new BigUint64Array(740));
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(26).fill(172), /* required buffer size: 26 */
{offset: 26, rowsPerImage: 108}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let imageData19 = new ImageData(44, 32);
let textureView184 = texture166.createView({dimension: '2d-array'});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({label: '\u082b\u0d4b\u00e1', colorFormats: ['rgb10a2uint'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder92.setBindGroup(3, bindGroup20, new Uint32Array(919), 55, 0);
} catch {}
try {
renderPassEncoder28.setBindGroup(1, bindGroup31);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup15, new Uint32Array(197), 34, 0);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(6, buffer42, 1_872, 498);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeBuffer(buffer12, 4384, new Int16Array(34539), 12679, 256);
} catch {}
try {
  await promise14;
} catch {}
let computePassEncoder130 = commandEncoder154.beginComputePass();
try {
computePassEncoder49.setBindGroup(2, bindGroup7, new Uint32Array(3029), 571, 0);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer25, 'uint16', 386, 458);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup12);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(1, buffer95, 2_524, 3_710);
} catch {}
document.body.append(canvas0);
let commandEncoder158 = device0.createCommandEncoder({label: '\u{1fc5a}\uf37e\u04f9\ub64c\u{1f6b3}\u87a4\u{1fb31}\udc6c\ub85c\u521e\u6826'});
let textureView185 = texture24.createView({mipLevelCount: 1});
let renderPassEncoder32 = commandEncoder156.beginRenderPass({
  colorAttachments: [{
  view: textureView94,
  clearValue: { r: -117.1, g: 346.2, b: -849.0, a: -542.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet6,
});
try {
renderPassEncoder13.setBindGroup(3, bindGroup41);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup52, new Uint32Array(1244), 337, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(3);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup15, new Uint32Array(1664), 347, 0);
} catch {}
try {
commandEncoder158.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 352 */
  offset: 352,
  bytesPerRow: 25600,
  buffer: buffer87,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, {width: 8, height: 9, depthOrArrayLayers: 0});
} catch {}
let buffer102 = device0.createBuffer({
  size: 31870,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let textureView186 = texture88.createView({dimension: '2d-array'});
try {
renderPassEncoder29.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer16, 'uint16', 892, 3_950);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer31, 0, 2_800);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup13);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(3, buffer40, 596, 374);
} catch {}
try {
commandEncoder158.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1738 */
  offset: 1738,
  bytesPerRow: 23808,
  buffer: buffer36,
}, {
  texture: texture203,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
}, {width: 5, height: 6, depthOrArrayLayers: 0});
} catch {}
let commandEncoder159 = device0.createCommandEncoder({});
let textureView187 = texture159.createView({aspect: 'all', mipLevelCount: 1});
let computePassEncoder131 = commandEncoder159.beginComputePass({});
let renderBundle22 = renderBundleEncoder22.finish();
let sampler90 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 98.03,
  lodMaxClamp: 99.59,
});
try {
renderPassEncoder13.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup26, new Uint32Array(2744), 546, 0);
} catch {}
let commandEncoder160 = device0.createCommandEncoder({});
try {
renderPassEncoder24.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder29.setScissorRect(2, 19, 8, 5);
} catch {}
let commandEncoder161 = device0.createCommandEncoder();
let textureView188 = texture63.createView({
  label: '\u851e\u24d1\u0bcb\u03a4\u{1f7e2}\u{1fd31}\u0c93',
  baseMipLevel: 0,
  mipLevelCount: 1,
  arrayLayerCount: 10,
});
let textureView189 = texture172.createView({mipLevelCount: 1});
try {
computePassEncoder14.setBindGroup(2, bindGroup24, new Uint32Array(281), 5, 0);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder19.setViewport(9.136187879670729, 6.459498483812447, 41.24886071961832, 26.842192039094368, 0.25475828565095204, 0.5879022269126513);
} catch {}
try {
commandEncoder158.clearBuffer(buffer36, 2252, 3736);
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
let bindGroup86 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 71, resource: {buffer: buffer92, offset: 7424, size: 2256}},
    {binding: 7, resource: {buffer: buffer9, offset: 0, size: 2907}},
  ],
});
let buffer103 = device0.createBuffer({size: 6527, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder162 = device0.createCommandEncoder();
let texture208 = device0.createTexture({
  label: '\u02ec\u{1f857}\u0db5\u02f7\u3aa1\u09cc\u3559\uac50',
  size: [1290, 8, 55],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder10.setBindGroup(3, bindGroup67, new Uint32Array(1436), 245, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer93, 736, new BigUint64Array(27641), 1763, 272);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let commandEncoder163 = device0.createCommandEncoder({});
let renderPassEncoder33 = commandEncoder160.beginRenderPass({colorAttachments: [{view: textureView94, loadOp: 'load', storeOp: 'store'}]});
try {
computePassEncoder28.setBindGroup(1, bindGroup40);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup67, new Uint32Array(2263), 531, 0);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -285.8, g: -783.0, b: 720.9, a: 325.5, });
} catch {}
try {
commandEncoder162.clearBuffer(buffer100);
} catch {}
let querySet21 = device0.createQuerySet({type: 'occlusion', count: 216});
let texture209 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 128},
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], sampleCount: 4});
let renderBundle23 = renderBundleEncoder23.finish({});
try {
computePassEncoder85.setBindGroup(1, bindGroup86, new Uint32Array(298), 6, 0);
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
let textureView190 = texture24.createView({mipLevelCount: 2});
try {
renderPassEncoder0.setBindGroup(3, bindGroup11, new Uint32Array(3460), 2_599, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer24, 'uint16', 1_862, 1_567);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder163.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2776 */
  offset: 2776,
  rowsPerImage: 404,
  buffer: buffer28,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 68, y: 0, z: 25},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture13.label;
} catch {}
let commandEncoder164 = device0.createCommandEncoder({label: '\u{1fd5e}\u9791\u{1fb96}\u69e7\u0467\u{1ff8b}\u{1fac8}\u{1f76d}\u53cc\u{1fc3a}\u0f56'});
let texture210 = device0.createTexture({
  label: '\uf2ff\u{1f981}\ua1c3\u7ac2\ub2c4\u0fd3\u0d69\u5789\u0e53\u{1fb08}\ue1c9',
  size: [2, 2, 27],
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler91 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.55,
  lodMaxClamp: 75.38,
  maxAnisotropy: 17,
});
try {
computePassEncoder128.setBindGroup(1, bindGroup32);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup13);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer8, 'uint16', 3_122, 2_824);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let bindGroup87 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer52, offset: 0, size: 3602}},
    {binding: 37, resource: textureView21},
  ],
});
let textureView191 = texture47.createView({label: '\u{1fdb5}\u04be\u6785\u41e7\u536e'});
let renderPassEncoder34 = commandEncoder163.beginRenderPass({
  colorAttachments: [{
  view: textureView170,
  clearValue: { r: -854.3, g: 985.1, b: -488.1, a: -662.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder12.setIndexBuffer(buffer43, 'uint32', 88, 134);
} catch {}
try {
commandEncoder162.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 518 */
  offset: 518,
  buffer: buffer5,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture211 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView192 = texture209.createView({});
let computePassEncoder132 = commandEncoder164.beginComputePass({});
try {
renderPassEncoder20.setBindGroup(0, bindGroup55, new Uint32Array(446), 52, 0);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer30, 'uint32', 1_132, 482);
} catch {}
let commandEncoder165 = device0.createCommandEncoder({label: '\u086f\ua393\u94a5\u40d3\u05d6\u0bab\u{1f7eb}\u{1fd0c}\u071e'});
try {
buffer55.unmap();
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let commandEncoder166 = device0.createCommandEncoder({});
try {
renderPassEncoder12.setIndexBuffer(buffer39, 'uint16', 3_766, 747);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer11, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let arrayBuffer12 = buffer0.getMappedRange(96, 0);
try {
commandEncoder158.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 248 */
  offset: 248,
  bytesPerRow: 1536,
  buffer: buffer12,
}, {
  texture: texture203,
  mipLevel: 0,
  origin: {x: 9, y: 1, z: 0},
  aspect: 'all',
}, {width: 0, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder158.copyTextureToBuffer({
  texture: texture98,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 28 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2194 */
  offset: 2194,
  buffer: buffer80,
}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: canvas2,
  origin: { x: 155, y: 22 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer104 = device0.createBuffer({size: 22134, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let computePassEncoder133 = commandEncoder158.beginComputePass({});
try {
computePassEncoder16.setBindGroup(1, bindGroup63);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(5, buffer89);
} catch {}
try {
commandEncoder166.copyBufferToBuffer(buffer49, 48, buffer37, 1004, 1380);
} catch {}
try {
commandEncoder161.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 238 */
  offset: 238,
  bytesPerRow: 29440,
  rowsPerImage: 660,
  buffer: buffer104,
}, {
  texture: texture180,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder166.resolveQuerySet(querySet18, 91, 1, buffer37, 4608);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 10, depthOrArrayLayers: 1}
*/
{
  source: videoFrame16,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture152,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let imageData20 = new ImageData(128, 20);
let computePassEncoder134 = commandEncoder165.beginComputePass({label: '\u{1fc86}\u0de3\u{1f6a4}\u0261\u1255'});
let sampler92 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 16.94,
  lodMaxClamp: 83.09,
});
try {
renderPassEncoder28.setBindGroup(1, bindGroup1, new Uint32Array(284), 40, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer72, 'uint16', 6_654, 73);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(3, buffer55);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm'],
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer48, 108, new BigUint64Array(14535), 4652, 16);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

requires unrestricted_pointer_parameters;

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

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

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

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

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

@group(1) @binding(2) var tex16: texture_2d<f32>;

@group(1) @binding(5) var st8: texture_storage_3d<rg32float, write>;

@group(1) @binding(8) var tex17: texture_cube<f32>;

@group(1) @binding(15) var tex18: texture_depth_2d;

@group(1) @binding(20) var et0: texture_external;

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

@group(1) @binding(33) var st9: texture_storage_1d<rgba8uint, write>;

@group(1) @binding(34) var sam1: sampler;

@group(1) @binding(36) var sam2: sampler;

@group(1) @binding(38) var sam3: sampler;

@group(1) @binding(47) var sam4: sampler;

@group(1) @binding(49) var<storage, read_write> buffer105: array<f16, 736>;

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

@group(1) @binding(55) var<storage, read> buffer106: array<array<array<f16, 1>, 6>, 3>;

@group(1) @binding(61) var st10: texture_storage_1d<bgra8unorm, write>;

@group(1) @binding(62) var sam5: sampler_comparison;

@group(1) @binding(65) var tex19: texture_depth_2d;

@group(1) @binding(67) var tex20: texture_2d<f32>;

@group(1) @binding(68) var<storage, read_write> buffer107: array<array<array<f16, 3>, 23>>;

@group(1) @binding(95) var sam6: sampler;

@group(1) @binding(99) var<uniform> buffer108: array<array<S2, 1>, 1>;

@group(1) @binding(112) var tex21: texture_cube<f32>;

@group(1) @binding(117) var<uniform> buffer109: vec2f;

@group(1) @binding(118) var tex22: texture_depth_2d;

@group(1) @binding(125) var tex23: texture_depth_2d;

@group(1) @binding(135) var et2: texture_external;

@group(1) @binding(141) var tex24: texture_cube<u32>;

@group(1) @binding(142) var tex25: texture_1d<u32>;

@group(1) @binding(161) var tex26: texture_2d<f32>;

@group(1) @binding(162) var st11: texture_storage_2d<rgba32sint, read>;

@group(1) @binding(195) var tex27: texture_2d<u32>;

@group(1) @binding(209) var tex28: texture_2d<u32>;

@group(1) @binding(216) var<uniform> buffer110: array<array<mat4x2h, 3>, 34>;

@group(1) @binding(228) var<storage, read> buffer111: array<f16, 1568>;

@group(1) @binding(232) var<storage, read> buffer112: array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 7>, 1>, 56>, 1>>;

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

@group(1) @binding(328) var tex29: texture_2d<u32>;

@group(1) @binding(330) var<uniform> buffer114: array<vec4i, 19>;

@group(1) @binding(348) var tex30: texture_2d<u32>;

@group(1) @binding(384) var et3: texture_external;

@group(1) @binding(408) var tex31: texture_1d<u32>;

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

@group(1) @binding(697) var<storage, read_write> buffer115: array<array<f16, 1>, 8>;

@group(1) @binding(712) var<storage, read> buffer116: array<S3, 28>;

struct T0 {
  @size(312) f0: array<array<mat2x2f, 2>, 9>,
}

struct T1 {
  f0: vec2f,
}

struct T2 {
  f0: vec4f,
  @size(72) f1: array<array<mat4x4h, 2>, 1>,
  @size(232) f2: array<array<mat2x3h, 14>, 1>,
}

struct S2 {
  @location(2) f0: vec4u,
  @location(14) f1: vec4f,
}

struct VertexOutput5 {
  @invariant @builtin(position) f14: vec4f,
}

struct S3 {
  @invariant @builtin(position) f0: vec4f,
}

struct FragmentOutput2 {
  @location(0) f0: vec4u,
}

alias vec3b = vec3<bool>;

fn fn0(a0: T1, a1: S3) -> array<f32, 1> {
  var out: array<f32, 1>;
  var vf49: bool = all(bool(unconst_bool(false)));
  var vf50: f32 = a1.f0[u32(unconst_u32(161))];
  out[u32(unconst_u32(16))] *= textureLoad(tex20, vec2i(unconst_i32(113), unconst_i32(192)), i32(unconst_i32(43)))[0];
  let vf51: f32 = a0.f0[u32(unconst_u32(118))];
  let vf52: vec4f = ldexp(vec4f(unconst_f32(0.00883), unconst_f32(0.5994), unconst_f32(0.00420), unconst_f32(0.9924)), vec4i(unconst_i32(-166), unconst_i32(31), unconst_i32(119), unconst_i32(80)));
  vf50 += f32(textureNumLevels(tex19));
  let vf53: vec4f = textureGather(tex19, sam1, vec2f(unconst_f32(0.4751), unconst_f32(0.04095)), clamp(vec2i(244, 174), vec2i(-8), vec2i(7)));
  var vf54: u32 = textureNumLevels(tex23);
  vf49 = bool(textureDimensions(tex23, i32(unconst_i32(41))).r);
  out[u32(unconst_u32(9))] = textureSampleBaseClampToEdge(et0, sam1, vec2f(unconst_f32(0.02580), unconst_f32(-0.05825)))[2];
  var vf55: f32 = vf52[u32(unconst_u32(283))];
  let vf56: vec4f = textureSampleLevel(tex26, sam3, vec2f(unconst_f32(0.01589), unconst_f32(0.05673)), f32(unconst_f32(0.2503)));
  vp3.f0 = vec2f(f32(pack4x8unorm(vec4f(unconst_f32(-0.09591), unconst_f32(0.4523), unconst_f32(0.03721), unconst_f32(1.000)))));
  vp1.f0 = vec4u(pack4x8unorm(vec4f(unconst_f32(0.08435), unconst_f32(0.06678), unconst_f32(0.09215), unconst_f32(0.1442))));
  vf54 *= u32(vf53[1]);
  vp2 = mat3x2h(vec2h(textureDimensions(et0)), vec2h(textureDimensions(et0)), vec2h(textureDimensions(et0)));
  return out;
}

fn fn1(a0: ptr<uniform, array<vec4u, 1>>) -> array<array<array<array<array<array<u32, 1>, 1>, 1>, 1>, 1>, 46> {
  var out: array<array<array<array<array<array<u32, 1>, 1>, 1>, 1>, 1>, 46>;
  var vf57: vec4u = textureGather(302 % 4, tex28, sam1, vec2f(unconst_f32(-0.1144), unconst_f32(0.03794)));
  var vf58: vec4f = textureSampleBaseClampToEdge(et2, sam1, vec2f(unconst_f32(-0.03057), unconst_f32(-0.02546)));
  var vf59: f16 = vp2[u32(unconst_u32(206))][u32(unconst_u32(23))];
  let ptr50: ptr<private, FragmentOutput2> = &vp1;
  var vf60: f32 = textureLoad(tex23, vec2i(unconst_i32(152), unconst_i32(360)), i32(unconst_i32(116)));
  fn0(T1(asinh(vec2f(unconst_f32(0.00303), unconst_f32(0.3483)))), S3(vec4f(f32(vf57[u32(unconst_u32(69))]))));
  var vf61 = fn0(T1(unpack2x16float(textureNumLevels(tex26))), S3(textureGather(tex19, sam1, vec2f(unconst_f32(0.06256), unconst_f32(0.3155)), clamp(vec2i(-401, 103), vec2i(-8), vec2i(7)))));
  var vf62: vec4f = textureSampleBaseClampToEdge(et2, sam3, vec2f(unconst_f32(0.1102), unconst_f32(0.1251)));
  let vf63: u32 = vp1.f0[u32(unconst_u32(32))];
  let vf64: vec2u = textureDimensions(tex26);
  let vf65: vec4f = textureLoad(et0, vec2u(unconst_u32(290), unconst_u32(194)));
  vf62 = vec4f(reflect(vec3h(unconst_f16(3618.3), unconst_f16(-32986.6), unconst_f16(20458.2)), vec3h(textureSampleBaseClampToEdge(et0, sam3, vec2f(unconst_f32(0.2997), unconst_f32(0.05123))).wzy)).yyyx);
  fn0(T1(), S3());
  vf62 *= textureGather(120 % 4, tex20, sam1, vec2f(unconst_f32(0.1002), unconst_f32(0.3595)));
  fn0(T1(textureGather(440 % 4, tex26, sam3, vec2f(unconst_f32(0.3855), unconst_f32(0.09746)), clamp(vec2i(59, 72), vec2i(-8), vec2i(7))).yw), S3(vec4f(unconst_f32(0.09340), unconst_f32(0.1387), unconst_f32(0.2318), unconst_f32(0.2982))));
  var vf66: f32 = vf58[u32(unconst_u32(353))];
  vp2 -= mat3x2h(vec2h(textureDimensions(et0)), vec2h(textureDimensions(et0)), vec2h(textureDimensions(et0)));
  var vf67: vec4f = fract(vec4f(unconst_f32(0.02315), unconst_f32(0.00206), unconst_f32(0.1717), unconst_f32(0.1031)));
  var vf68 = fn0(T1(vec2f(textureGather(248 % 4, tex27, sam3, vec2f(unconst_f32(0.2841), unconst_f32(0.2781))).aa)), S3(bitcast<vec4f>(textureDimensions(et2).grrr)));
  vp3.f0 = vec2f(vf62[u32(unconst_u32(339))]);
  vf61[u32(unconst_u32(9))] += vf65.g;
  return out;
}

var<workgroup> vw17: S2;

var<workgroup> vw18: array<T1, 21>;

var<workgroup> vw19: array<i32, 1>;

var<workgroup> vw20: bool;

var<workgroup> vw21: array<atomic<i32>, 11>;

var<workgroup> vw22: mat3x3h;

var<workgroup> vw23: S3;

var<workgroup> vw24: atomic<u32>;

var<private> vp1: FragmentOutput2 = FragmentOutput2(vec4u(251, 37, 258, 65));

var<private> vp2: mat3x2h = mat3x2h(41304.4, 11855.5, 10654.5, 14449.8, 10817.3, 2140.5);

var<private> vp3: T1 = T1();

@vertex @must_use
fn vertex5(@location(7) a0: vec4f, @location(1) a1: u32, a2: S2, @location(5) a3: vec4i) -> @builtin(position) vec4f {
  var out: vec4f;
  vp2 -= mat3x2h((*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(45))][55][u32(unconst_u32(428))][6][0][0][0], (*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(45))][55][u32(unconst_u32(428))][6][0][0][0], (*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(45))][55][u32(unconst_u32(428))][6][0][0][0], (*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(45))][55][u32(unconst_u32(428))][6][0][0][0], (*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(45))][55][u32(unconst_u32(428))][6][0][0][0], (*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(45))][55][u32(unconst_u32(428))][6][0][0][0]);
  let ptr51: ptr<storage, f16, read> = &buffer112[arrayLength(&buffer112)][u32(unconst_u32(15))][u32(unconst_u32(118))][u32(unconst_u32(44))][6][u32(unconst_u32(559))][0][u32(buffer112[u32(unconst_u32(156))][u32(unconst_u32(89))][55][0][6][u32(unconst_u32(93))][0][0])];
  let ptr52: ptr<storage, array<f16, 1>, read> = &buffer112[arrayLength(&buffer112)][u32(unconst_u32(23))][u32(unconst_u32(207))][u32(unconst_u32(408))][textureGather(234 % 4, tex27, sam3, vec2f(f32(buffer112[arrayLength(&buffer112)][u32(unconst_u32(225))][55][0][6][u32(unconst_u32(211))][u32(unconst_u32(84))][u32(unconst_u32(446))])))[3]][0][u32(buffer112[u32(unconst_u32(59))][0][55][0][u32(unconst_u32(92))][u32((*&buffer112)[u32(buffer112[u32(unconst_u32(110))][u32(buffer112[u32(unconst_u32(100))][u32(unconst_u32(465))][u32(unconst_u32(152))][u32(unconst_u32(553))][6][u32(unconst_u32(17))][0][0])][u32(unconst_u32(122))][0][6][u32(unconst_u32(59))][u32(unconst_u32(70))][0])][0][55][0][6][0][0][0])][0][0])];
  vp2 = mat3x2h(buffer112[u32(unconst_u32(31))][u32(unconst_u32(39))][55][0][u32(unconst_u32(57))][u32(unconst_u32(91))][u32(unconst_u32(58))][0], buffer112[u32(unconst_u32(31))][u32(unconst_u32(39))][55][0][u32(unconst_u32(57))][u32(unconst_u32(91))][u32(unconst_u32(58))][0], buffer112[u32(unconst_u32(31))][u32(unconst_u32(39))][55][0][u32(unconst_u32(57))][u32(unconst_u32(91))][u32(unconst_u32(58))][0], buffer112[u32(unconst_u32(31))][u32(unconst_u32(39))][55][0][u32(unconst_u32(57))][u32(unconst_u32(91))][u32(unconst_u32(58))][0], buffer112[u32(unconst_u32(31))][u32(unconst_u32(39))][55][0][u32(unconst_u32(57))][u32(unconst_u32(91))][u32(unconst_u32(58))][0], buffer112[u32(unconst_u32(31))][u32(unconst_u32(39))][55][0][u32(unconst_u32(57))][u32(unconst_u32(91))][u32(unconst_u32(58))][0]);
  return out;
}

@vertex
fn vertex6(@location(9) @interpolate(flat) a0: vec4h, @location(8) a1: vec4h, @location(4) @interpolate(flat, center) a2: vec2i, @location(7) @interpolate(flat) a3: u32, @builtin(instance_index) a4: u32, @location(1) a5: vec2i, @location(6) @interpolate(flat) a6: vec2i, @location(11) @interpolate(linear, sample) a7: vec2f) -> VertexOutput5 {
  var out: VertexOutput5;
  let ptr53: ptr<storage, array<f16, 1>, read> = &buffer112[arrayLength(&buffer112)][0][u32(unconst_u32(194))][0][6][0][u32(unconst_u32(28))];
  var vf69 = fn0(T1(vec2f(f32((*&buffer112)[arrayLength(&(*&buffer112))][0][55][u32(unconst_u32(186))][u32(unconst_u32(494))][u32(unconst_u32(11))][u32(unconst_u32(187))][u32(unconst_u32(338))]))), S3(vec4f(f32(buffer112[arrayLength(&buffer112)][0][55][0][u32(unconst_u32(43))][0][0][0]))));
  out.f14 = vec4f(f32((*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(664))][55][0][u32(unconst_u32(122))][u32(unconst_u32(82))][0][0]));
  out.f14 *= vec4f(f32(buffer112[arrayLength(&buffer112)][0][55][0][u32(unconst_u32(401))][u32(unconst_u32(30))][u32(unconst_u32(114))][0]));
  fn0(T1(vec2f(f32((*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(17))][u32(unconst_u32(548))][u32(unconst_u32(103))][u32(unconst_u32(323))][u32(unconst_u32(25))][u32(unconst_u32(308))][u32(unconst_u32(163))]))), S3(vec4f(f32(buffer112[u32(unconst_u32(503))][0][u32((*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(87))][55][u32((*&buffer112)[u32(unconst_u32(163))][0][55][0][6][0][0][0])][u32(unconst_u32(30))][u32(unconst_u32(208))][u32(unconst_u32(479))][0])][u32(unconst_u32(21))][6][u32((*&buffer112)[arrayLength(&(*&buffer112))][u32(unconst_u32(378))][u32(unconst_u32(11))][0][u32(unconst_u32(23))][u32(unconst_u32(50))][0][0])][u32(unconst_u32(153))][0]))));
  let ptr54: ptr<storage, array<f16, 1>, read> = &buffer112[arrayLength(&buffer112)][u32(unconst_u32(419))][u32(unconst_u32(343))][u32(unconst_u32(125))][6][0][0];
  var vf70 = fn0(T1(vec2f(f32(buffer112[arrayLength(&buffer112)][u32(unconst_u32(194))][55][0][6][0][0][0]))), S3(vec4f(f32((*&buffer112)[u32(unconst_u32(116))][0][u32(unconst_u32(275))][0][u32(unconst_u32(58))][0][0][u32(unconst_u32(271))]))));
  var vf71 = fn0(T1(vec2f(f32((*&buffer112)[u32(unconst_u32(254))][u32(unconst_u32(140))][u32(unconst_u32(164))][u32(unconst_u32(107))][u32(unconst_u32(1))][0][0][0]))), S3(vec4f(unconst_f32(0.1144), unconst_f32(0.04558), unconst_f32(0.2246), unconst_f32(0.1427))));
  vp1.f0 += textureGather(61 % 4, tex24, sam1, vec3f(unconst_f32(0.06965), unconst_f32(0.2087), unconst_f32(-0.3745)));
  let ptr55: ptr<storage, f16, read> = &buffer112[u32(unconst_u32(420))][0][u32(unconst_u32(50))][0][u32(unconst_u32(23))][0][u32(unconst_u32(51))][u32(unconst_u32(68))];
  let ptr56: ptr<storage, f16, read> = &buffer112[arrayLength(&buffer112)][u32(unconst_u32(205))][55][u32(unconst_u32(19))][6][bitcast<u32>(buffer114[u32(unconst_u32(93))][u32(unconst_u32(93))])][0][u32(unconst_u32(263))];
  let ptr57: ptr<storage, f16, read> = &(*&buffer112)[arrayLength(&(*&buffer112))][0][u32(unconst_u32(434))][u32(unconst_u32(4))][6][0][u32(unconst_u32(157))][u32(buffer112[u32(unconst_u32(244))][0][55][0][6][0][u32(unconst_u32(202))][0])];
  vf70[u32(unconst_u32(98))] = f32(buffer112[u32(unconst_u32(307))][u32(unconst_u32(42))][u32(unconst_u32(148))][u32(unconst_u32(406))][6][0][0][0]);
  vf69[u32(unconst_u32(157))] = f32((*&buffer112)[u32(unconst_u32(19))][0][u32(unconst_u32(215))][0][6][0][u32(unconst_u32(526))][0]);
  return out;
}

@fragment
fn fragment3(@location(10) a0: vec2f, @builtin(sample_mask) a1: u32, a2: S3) -> FragmentOutput2 {
  var out: FragmentOutput2;
  out = FragmentOutput2(vec4u(u32(textureSampleLevel(tex22, sam1, vec2f(unconst_f32(0.3429), unconst_f32(-0.03272)), i32(unconst_i32(-32))))));
  buffer113[u32(unconst_u32(24))][u32(unconst_u32(1))][u32(unconst_u32(71))][u32(unconst_u32(137))] = buffer107[u32(unconst_u32(15))][u32(unconst_u32(331))][2];
  var vf72: vec2u = textureDimensions(et0);
  vp1 = FragmentOutput2(textureDimensions(tex17, i32(unconst_i32(-137))).ggrg);
  let ptr58: ptr<storage, array<f16, 1>, read_write> = &buffer113[5][u32(unconst_u32(26))][u32(unconst_u32(71))];
  var vf73: vec4u = textureGather(141 % 4, tex28, sam6, vec2f(unconst_f32(0.1425), unconst_f32(0.1538)));
  vp2 = mat3x2h(vec2h(textureDimensions(et2)), vec2h(textureDimensions(et2)), vec2h(textureDimensions(et2)));
  let vf74: vec4f = textureGather(tex19, sam3, vec2f(unconst_f32(0.2199), unconst_f32(-0.3475)));
  vf72 <<= bitcast<vec2u>(textureSampleBias(tex26, sam3, vec2f(unconst_f32(0.00290), unconst_f32(0.02582)), f32(unconst_f32(0.07047))).rr);
  let ptr59: ptr<private, vec4u> = &vp1.f0;
  buffer113[u32(unconst_u32(147))][u32(unconst_u32(100))][u32(unconst_u32(155))][u32(unconst_u32(84))] = vec4h(textureGather(tex22, sam6, vec2f(unconst_f32(0.3188), unconst_f32(0.06416)), clamp(vec2i(193, 49), vec2i(-8), vec2i(7)))).w;
  buffer107[u32(unconst_u32(22))][u32(buffer113[5][u32(unconst_u32(459))][0][u32(unconst_u32(110))])][u32(unconst_u32(32))] = vec4h(textureGather(24 % 4, tex20, sam1, vec2f(unconst_f32(0.1974), unconst_f32(0.3364))))[0];
  let ptr60: ptr<storage, f16, read_write> = &buffer107[u32(unconst_u32(127))][22][2];
  discard;
  let ptr61: ptr<storage, f16, read_write> = &(*&buffer113)[u32(buffer113[u32(unconst_u32(520))][0][0][0])][0][0][u32(unconst_u32(13))];
  vf73 <<= vec4u(u32(buffer113[5][pack4xU8Clamp(vec4u(textureGather(108 % 4, tex26, sam6, vec2f(unconst_f32(0.09709), unconst_f32(0.04496)), clamp(vec2i(360, 101), vec2i(-8), vec2i(7)))))][0][0]));
  vf73 ^= vec4u(select(vec2h(unconst_f16(24519.8), unconst_f16(34.98)), vec2h(unconst_f16(2280.6), unconst_f16(17296.8)), bool(unconst_bool(true))).xyyy);
  fn0(T1(vec2f(unconst_f32(0.1640), unconst_f32(0.2610))), S3(vec4f(f32(buffer113[u32(unconst_u32(141))][0][u32(unconst_u32(443))][0]))));
  vf72 = vec2u(u32(buffer113[u32(unconst_u32(31))][0][0][u32(unconst_u32(34))]));
  var vf75: vec2u = textureDimensions(et2);
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute2(@builtin(local_invocation_id) a0: vec3u) {
  let ptr62: ptr<storage, array<f16, 1>, read> = &(*&buffer106)[2][u32(unconst_u32(247))];
  vw18[u32(unconst_u32(438))] = T1(vec2f(f32(buffer106[u32(unconst_u32(19))][5][0])));
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup88 = device0.createBindGroup({
  layout: bindGroupLayout20,
  entries: [
    {binding: 259, resource: {buffer: buffer77, offset: 512, size: 2337}},
    {binding: 27, resource: sampler76},
  ],
});
let textureView193 = texture192.createView({label: '\u{1ffc7}\u{1f8d0}\u2e09\u{1fc09}\u0309\u0623\u02f0'});
let texture212 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 62},
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder118.setBindGroup(3, bindGroup34, new Uint32Array(1142), 589, 0);
} catch {}
try {
renderPassEncoder23.beginOcclusionQuery(4);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(3, buffer28, 0, 156);
} catch {}
try {
commandEncoder162.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 7448 */
  offset: 7448,
  buffer: buffer79,
}, {
  texture: texture160,
  mipLevel: 0,
  origin: {x: 5, y: 2, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder162.clearBuffer(buffer94);
} catch {}
let bindGroup89 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 219, resource: textureView61}]});
try {
commandEncoder162.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1538 */
  offset: 1538,
  bytesPerRow: 58112,
  buffer: buffer12,
}, {
  texture: texture180,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise16;
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(43, 260);
let imageBitmap5 = await createImageBitmap(imageData5);
let querySet22 = device0.createQuerySet({label: '\u89e8\u0d16\u5916\u050f', type: 'occlusion', count: 353});
try {
computePassEncoder63.setBindGroup(1, bindGroup64);
} catch {}
try {
computePassEncoder131.setBindGroup(1, bindGroup72, new Uint32Array(2128), 1_228, 0);
} catch {}
try {
commandEncoder166.copyBufferToTexture({
  /* bytesInLastRow: 192 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 856 */
  offset: 856,
  bytesPerRow: 36096,
  buffer: buffer94,
}, {
  texture: texture211,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder161.copyTextureToBuffer({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1228 */
  offset: 1228,
  buffer: buffer42,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder161.copyTextureToTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture153,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(51).fill(171), /* required buffer size: 51 */
{offset: 51}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 15}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext8 = offscreenCanvas3.getContext('webgpu');
let commandEncoder167 = device0.createCommandEncoder();
try {
computePassEncoder121.setBindGroup(0, bindGroup76);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup47, new Uint32Array(4351), 391, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroupLayout22 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 92,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 46,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 440,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 594,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let texture213 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView194 = texture99.createView({
  label: '\u5530\u1977\ua70d\u3fa4\u0d59\u07c3\u{1fb78}',
  dimension: '2d',
  baseMipLevel: 0,
  baseArrayLayer: 2,
});
try {
renderPassEncoder7.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer89, 'uint32', 2_892, 3_297);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let commandEncoder168 = device0.createCommandEncoder({});
let textureView195 = texture79.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 16});
let computePassEncoder135 = commandEncoder168.beginComputePass();
try {
computePassEncoder132.setBindGroup(3, bindGroup66, new Uint32Array(2220), 1, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer91, 'uint32', 1_928, 1_759);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 4608, new BigUint64Array(61), 1, 20);
} catch {}
let textureView196 = texture75.createView({label: '\uccdb\u0d19\u{1fedf}\u9183\u084a\u939f\u9144\ud008'});
let renderPassEncoder35 = commandEncoder166.beginRenderPass({
  colorAttachments: [{
  view: textureView94,
  clearValue: { r: 246.7, g: 897.3, b: 714.0, a: -17.31, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder40.setBindGroup(0, bindGroup41);
} catch {}
try {
computePassEncoder63.setBindGroup(1, bindGroup7, new Uint32Array(514), 212, 0);
} catch {}
try {
renderPassEncoder23.endOcclusionQuery();
} catch {}
document.body.append(img0);
canvas4.width = 319;
let textureView197 = texture210.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 1});
let renderPassEncoder36 = commandEncoder167.beginRenderPass({
  colorAttachments: [{
  view: textureView144,
  clearValue: { r: -863.0, g: 371.4, b: 857.8, a: -160.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 149075990,
});
try {
commandEncoder161.copyBufferToTexture({
  /* bytesInLastRow: 14 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 142 */
  offset: 142,
  rowsPerImage: 372,
  buffer: buffer33,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer117 = device0.createBuffer({size: 5852, usage: GPUBufferUsage.INDEX});
let computePassEncoder136 = commandEncoder162.beginComputePass({label: '\u00ac\u4b32\u024b\uc028\u7272\u01b5\u0996\u3be8\ucca4'});
try {
computePassEncoder19.setBindGroup(2, bindGroup79);
} catch {}
try {
buffer30.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer28, 536, new BigUint64Array(4397), 71, 36);
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: bindGroupLayout22,
  entries: [
    {binding: 92, resource: textureView195},
    {binding: 594, resource: textureView1},
    {binding: 440, resource: sampler43},
    {binding: 5, resource: textureView141},
    {binding: 46, resource: textureView179},
  ],
});
let buffer118 = device0.createBuffer({
  label: '\u0a5b\uf9d0\u5b57\u046d\u3866\ua9f9\ue365',
  size: 2976,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let texture214 = device0.createTexture({
  label: '\u06fe\u0810\ub595',
  size: {width: 52, height: 40, depthOrArrayLayers: 64},
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder137 = commandEncoder161.beginComputePass({});
try {
computePassEncoder105.setBindGroup(2, bindGroup41);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture170,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(71).fill(199), /* required buffer size: 71 */
{offset: 71}, {width: 250, height: 1, depthOrArrayLayers: 0});
} catch {}
let imageData21 = new ImageData(28, 28);
let texture215 = device0.createTexture({
  size: [1290, 8, 10],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder24.setBindGroup(1, bindGroup74);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer33, 'uint16', 1_974, 5_219);
} catch {}
try {
buffer82.unmap();
} catch {}
let sampler93 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 68.84,
  lodMaxClamp: 86.08,
  maxAnisotropy: 13,
});
try {
computePassEncoder16.setBindGroup(2, bindGroup10, new Uint32Array(696), 54, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup55);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer119 = device0.createBuffer({
  size: 10207,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView198 = texture165.createView({dimension: '2d', baseArrayLayer: 47});
let texture216 = device0.createTexture({
  size: [110, 16, 26],
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder67.setBindGroup(2, bindGroup35);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let imageBitmap6 = await createImageBitmap(canvas3);
let bindGroup91 = device0.createBindGroup({
  label: '\u{1fe70}\ucc43\u0a7d\u{1f980}\u0e16',
  layout: bindGroupLayout16,
  entries: [
    {binding: 44, resource: sampler41},
    {binding: 351, resource: {buffer: buffer20, offset: 6144, size: 282}},
    {binding: 14, resource: {buffer: buffer75, offset: 1024, size: 1123}},
    {binding: 185, resource: textureView179},
    {binding: 47, resource: textureView137},
    {binding: 160, resource: textureView53},
    {binding: 70, resource: textureView128},
    {binding: 12, resource: {buffer: buffer77, offset: 256, size: 3028}},
    {binding: 252, resource: {buffer: buffer40, offset: 0, size: 1248}},
    {binding: 8, resource: textureView117},
    {binding: 6, resource: textureView149},
    {binding: 195, resource: textureView162},
    {binding: 349, resource: sampler72},
    {binding: 68, resource: {buffer: buffer17, offset: 256, size: 1028}},
    {binding: 110, resource: textureView154},
    {binding: 143, resource: {buffer: buffer25, offset: 256, size: 479}},
    {binding: 190, resource: textureView142},
    {binding: 163, resource: sampler2},
    {binding: 0, resource: {buffer: buffer13, offset: 6400, size: 2640}},
    {binding: 255, resource: {buffer: buffer82, offset: 1024, size: 2104}},
    {binding: 287, resource: textureView86},
    {binding: 88, resource: textureView30},
    {binding: 389, resource: textureView140},
    {binding: 196, resource: textureView151},
    {binding: 79, resource: {buffer: buffer28, offset: 256, size: 760}},
    {binding: 523, resource: textureView169},
    {binding: 177, resource: textureView3},
    {binding: 306, resource: textureView90},
  ],
});
let commandEncoder169 = device0.createCommandEncoder({label: '\ubc60\ua920\u0413\ub512\ua05d\u2103\udcea\u755e\u{1f777}\u{1fea3}'});
let texture217 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 33},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder138 = commandEncoder169.beginComputePass({});
try {
computePassEncoder37.setBindGroup(0, bindGroup36);
} catch {}
try {
computePassEncoder137.setBindGroup(0, bindGroup57, new Uint32Array(650), 0, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer119, 'uint16', 4_328, 526);
} catch {}
let bindGroup92 = device0.createBindGroup({
  label: '\u5830\uff8f\u0dc6\uae24\u{1f663}',
  layout: bindGroupLayout13,
  entries: [
    {binding: 74, resource: textureView76},
    {binding: 380, resource: textureView179},
    {binding: 206, resource: textureView106},
    {binding: 220, resource: textureView100},
    {binding: 230, resource: textureView62},
    {binding: 119, resource: textureView188},
    {binding: 289, resource: textureView87},
    {binding: 196, resource: sampler10},
  ],
});
let commandEncoder170 = device0.createCommandEncoder();
try {
renderPassEncoder33.setVertexBuffer(6, buffer99, 484, 288);
} catch {}
let imageData22 = new ImageData(40, 4);
let textureView199 = texture85.createView({mipLevelCount: 1});
let computePassEncoder139 = commandEncoder170.beginComputePass({});
let externalTexture21 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder137.setBindGroup(1, bindGroup40, new Uint32Array(1163), 154, 0);
} catch {}
let bindGroup93 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 7, resource: {buffer: buffer97, offset: 512, size: 3292}},
    {binding: 71, resource: {buffer: buffer22, offset: 4608, size: 3264}},
  ],
});
let commandEncoder171 = device0.createCommandEncoder({});
let querySet23 = device0.createQuerySet({type: 'occlusion', count: 801});
let computePassEncoder140 = commandEncoder171.beginComputePass({});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer120 = device0.createBuffer({size: 7800, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder172 = device0.createCommandEncoder({});
let sampler94 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 55.26,
  compare: 'less-equal',
});
try {
commandEncoder172.copyBufferToBuffer(buffer76, 6236, buffer97, 64, 12);
} catch {}
let computePassEncoder141 = commandEncoder172.beginComputePass({});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], sampleCount: 4});
try {
renderPassEncoder30.beginOcclusionQuery(94);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup86, []);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(0, buffer38, 0, 173);
} catch {}
try {
  await buffer71.mapAsync(GPUMapMode.WRITE, 0, 60);
} catch {}
try {
device0.queue.writeBuffer(buffer18, 768, new Float32Array(4998), 863, 320);
} catch {}
let bindGroup94 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let buffer121 = device0.createBuffer({
  size: 3946,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let textureView200 = texture90.createView({
  label: '\uf6a2\u0687\ud942\u{1fbfd}\u{1fd75}\uf6f2',
  dimension: '2d-array',
  aspect: 'all',
  baseArrayLayer: 3,
  arrayLayerCount: 6,
});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, depthReadOnly: true});
let sampler95 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.52,
  lodMaxClamp: 99.89,
  maxAnisotropy: 18,
});
try {
renderBundleEncoder24.setIndexBuffer(buffer121, 'uint16', 180, 591);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(84).fill(9), /* required buffer size: 84 */
{offset: 84, bytesPerRow: 0, rowsPerImage: 236}, {width: 0, height: 0, depthOrArrayLayers: 11});
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); };
} catch {}
let bindGroup95 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 219, resource: textureView61}]});
let texture218 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 125},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer119, 'uint16', 360, 275);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder25.setBindGroup(0, bindGroup1, new Uint32Array(878), 17, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let externalTexture22 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder12.setBindGroup(1, bindGroup52);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup52, new Uint32Array(2341), 188, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer102, 'uint16', 562, 7_434);
} catch {}
try {
renderBundleEncoder25.setBindGroup(1, bindGroup3, new Uint32Array(2357), 347, 0);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(7, buffer17, 540);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let sampler96 = device0.createSampler({
  label: '\u89a2\u{1f78b}',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'linear',
  lodMinClamp: 30.74,
  lodMaxClamp: 82.85,
});
let externalTexture23 = device0.importExternalTexture({source: videoFrame8});
try {
renderBundleEncoder24.setBindGroup(3, bindGroup75, new Uint32Array(4038), 194, 0);
} catch {}
try {
renderPassEncoder26.pushDebugGroup('\u{1f7d2}');
} catch {}
let bindGroupLayout23 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 31,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 159,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 208,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let buffer122 = device0.createBuffer({
  size: 2520,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture219 = device0.createTexture({
  size: [52],
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture220 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler97 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 34.03,
  compare: 'greater',
  maxAnisotropy: 5,
});
try {
computePassEncoder57.setBindGroup(3, bindGroup93, new Uint32Array(1554), 621, 0);
} catch {}
try {
renderPassEncoder26.setBindGroup(0, bindGroup89, new Uint32Array(1042), 16, 0);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup66);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer47, 'uint32', 616, 4_611);
} catch {}
try {
device0.queue.writeBuffer(buffer37, 2040, new Int16Array(4197), 30, 68);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 5, y: 12 },
  flipY: false,
}, {
  texture: texture167,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

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

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

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

@group(1) @binding(2) var tex32: texture_2d<f32>;

@group(1) @binding(5) var st12: texture_storage_3d<rg32float, write>;

@group(1) @binding(8) var tex33: texture_cube<f32>;

@group(1) @binding(15) var tex34: texture_depth_2d;

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

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

@group(1) @binding(33) var st13: texture_storage_1d<rgba8uint, write>;

@group(1) @binding(34) var sam8: sampler;

@group(1) @binding(36) var sam9: sampler;

@group(1) @binding(38) var sam10: sampler;

@group(1) @binding(47) var sam11: sampler;

@group(1) @binding(49) var<storage, read_write> buffer123: array<atomic<i32>, 368>;

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

@group(1) @binding(55) var<storage, read> buffer124: array<array<array<array<f16, 9>, 1>, 2>>;

@group(1) @binding(62) var sam12: sampler_comparison;

@group(1) @binding(65) var tex35: texture_depth_2d;

@group(1) @binding(67) var tex36: texture_2d<f32>;

@group(1) @binding(68) var<storage, read_write> buffer125: array<array<array<f16, 1>, 23>, 3>;

@group(1) @binding(95) var sam13: sampler;

@group(1) @binding(99) var<uniform> buffer126: vec4u;

@group(1) @binding(112) var tex37: texture_cube<f32>;

@group(1) @binding(117) var<uniform> buffer127: vec4h;

@group(1) @binding(118) var tex38: texture_depth_2d;

@group(1) @binding(125) var tex39: texture_depth_2d;

@group(1) @binding(135) var et7: texture_external;

@group(1) @binding(141) var tex40: texture_cube<u32>;

@group(1) @binding(142) var tex41: texture_1d<u32>;

@group(1) @binding(161) var tex42: texture_2d<f32>;

@group(1) @binding(162) var st14: texture_storage_2d<rgba32sint, read>;

@group(1) @binding(195) var tex43: texture_2d<u32>;

@group(1) @binding(209) var tex44: texture_2d<u32>;

@group(1) @binding(216) var<uniform> buffer128: array<array<array<array<vec4i, 1>, 51>, 2>, 1>;

@group(1) @binding(228) var<storage, read> buffer129: array<array<f16, 8>, 196>;

@group(1) @binding(232) var<storage, read> buffer130: array<array<array<array<array<f16, 7>, 1>, 7>, 8>>;

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

@group(1) @binding(328) var tex45: texture_2d<u32>;

@group(1) @binding(330) var<uniform> buffer132: vec2f;

@group(1) @binding(348) var tex46: texture_2d<u32>;

@group(1) @binding(384) var et8: texture_external;

@group(1) @binding(408) var tex47: texture_1d<u32>;

@group(1) @binding(479) var et9: texture_external;

@group(1) @binding(697) var<storage, read_write> buffer133: array<vec4i>;

@group(1) @binding(712) var<storage, read> buffer134: array<array<array<array<array<array<f16, 1>, 7>, 2>, 2>, 8>, 1>;

struct T0 {
  f0: vec2f,
}

struct T1 {
  f0: array<mat2x2f, 1>,
  @size(296) f1: array<array<mat4x2f, 1>, 9>,
}

struct T2 {
  @size(48) f0: vec4u,
  @size(272) f1: mat2x2h,
}

struct T3 {
  @size(96) f0: array<T0, 1>,
  @align(16) f1: array<f32, 24>,
  @align(32) @size(352) f2: array<T0, 1>,
}

struct T4 {
  @size(40) f0: array<array<T0, 4>>,
}

struct T5 {
  @align(16) @size(1632) f0: array<u32>,
}

struct VertexOutput6 {
  @invariant @builtin(position) f15: vec4f,
  @location(12) @interpolate(flat, centroid) f16: vec4u,
  @location(4) @interpolate(linear, center) f17: vec2f,
  @location(9) @interpolate(flat, sample) f18: u32,
  @location(7) @interpolate(perspective, sample) f19: vec4h,
  @location(8) @interpolate(flat, sample) f20: vec2u,
  @location(0) @interpolate(flat, centroid) f21: vec4i,
}

struct FragmentOutput3 {
  @location(2) @interpolate(flat) f0: vec4u,
  @location(0) f1: vec4u,
  @location(4) f2: vec4f,
  @location(5) f3: vec4f,
  @location(1) @interpolate(flat) f4: f32,
  @location(3) f5: vec4f,
}

alias vec3b = vec3<bool>;

fn fn0(a0: ptr<uniform, vec4i>) -> T0 {
  var out: T0;
  let ptr63: ptr<storage, f16, read_write> = &(*&buffer125)[2][u32(unconst_u32(847))][u32(unconst_u32(6))];
  let ptr64: ptr<storage, array<f16, 1>, read_write> = &(*&buffer125)[2][22];
  out.f0 = vec2f(f32(buffer131[u32(textureSampleLevel(tex42, sam13, vec2f(unconst_f32(0.2032), unconst_f32(0.1735)), f32(unconst_f32(0.03414)), clamp(vec2i(67, 142), vec2i(-8), vec2i(7)))[0])][u32(textureGather(168 % 4, tex36, sam8, vec2f(unconst_f32(-0.09422), unconst_f32(0.3929)))[3])][2][u32(unconst_u32(29))]));
  textureStore(st12, vec3i(unconst_i32(-24), unconst_i32(597), unconst_i32(40)), vec4f(vec4f(unconst_f32(0.00931), unconst_f32(0.00544), unconst_f32(-0.1501), unconst_f32(0.03126))));
  out.f0 = vec2f(textureDimensions(tex36, i32(unconst_i32(-200))));
  out.f0 = vec2f(f32((*&buffer125)[2][u32(unconst_u32(141))][u32(unconst_u32(56))]));
  textureStore(st12, vec3i(unconst_i32(-61), unconst_i32(59), unconst_i32(57)), vec4f(vec4f(f32(buffer125[2][u32(unconst_u32(184))][u32(unconst_u32(500))]))));
  let ptr65: ptr<storage, array<f16, 1>, read_write> = &buffer125[u32(unconst_u32(34))][u32(unconst_u32(213))];
  let ptr66: ptr<storage, f16, read_write> = &(*&buffer125)[2][22][u32(unconst_u32(58))];
  let ptr67: ptr<storage, f16, read_write> = &buffer131[arrayLength(&buffer131)][u32((*&buffer125)[u32(unconst_u32(39))][u32(unconst_u32(168))][0])][2][u32(unconst_u32(70))];
  return out;
}

fn fn1(a0: ptr<storage, array<u32>, read_write>, a1: ptr<storage, FragmentOutput3, read_write>) -> f32 {
  var out: f32;
  buffer125[u32(unconst_u32(55))][u32(unconst_u32(522))][u32(unconst_u32(392))] *= buffer131[i32(unconst_i32(102))][1][2][0];
  let vf76: vec4f = textureSampleGrad(tex42, sam13, vec2f(unconst_f32(0.7159), unconst_f32(-0.1219)), vec2f(unconst_f32(0.1412), unconst_f32(-0.5068)), vec2f(unconst_f32(0.2883), unconst_f32(0.1687)), clamp(vec2i(37, 193), vec2i(-8), vec2i(7)));
  (*a0)[textureDimensions(tex38, bitcast<i32>(textureSample(tex39, sam13, vec2f(unconst_f32(0.1366), unconst_f32(0.07993)))))[1]] |= vec4u(textureSampleBias(tex42, sam10, vec2f(unconst_f32(0.1748), unconst_f32(0.1282)), f32(unconst_f32(-0.04507)), clamp(vec2i(385, 56), vec2i(-8), vec2i(7)))).w;
  buffer125[u32(unconst_u32(147))][22][u32(unconst_u32(36))] += (*&buffer131)[arrayLength(&(*&buffer131))][1][2][u32(unconst_u32(66))];
  (*a1).f5 -= textureSampleBaseClampToEdge(tex42, sam10, vec2f(unconst_f32(0.2497), unconst_f32(0.01404)));
  let ptr68: ptr<storage, array<array<f16, 1>, 3>, read_write> = &buffer131[u32(unconst_u32(127))][1];
  textureStore(st12, vec3i(unconst_i32(48), unconst_i32(-114), unconst_i32(220)), vec4f(vec4f(unconst_f32(-0.08642), unconst_f32(0.3232), unconst_f32(-0.09379), unconst_f32(0.1172))));
  let ptr69: ptr<storage, f16, read_write> = &buffer131[arrayLength(&buffer131)][u32(unconst_u32(52))][u32(unconst_u32(539))][u32(unconst_u32(219))];
  return out;
}

@vertex
fn vertex7(@location(5) @interpolate(flat) a0: vec4u, @location(11) a1: vec2h, @location(14) a2: u32, @location(6) a3: u32, @location(2) @interpolate(flat) a4: vec2f) -> VertexOutput6 {
  var out: VertexOutput6;
  let ptr70: ptr<uniform, array<array<array<array<vec4i, 1>, 51>, 2>, 1>> = &buffer128;
  var vf77: vec4f = textureSampleLevel(tex32, sam10, vec2f(unconst_f32(0.1639), unconst_f32(0.02363)), f32(unconst_f32(0.2729)), clamp(vec2i(26, 101), vec2i(-8), vec2i(7)));
  out.f21 *= bitcast<vec4i>(textureGather(tex39, sam9, vec2f(unpack4xU8(u32(unconst_u32(221))).rb)));
  let ptr71: ptr<uniform, vec4i> = &(*&buffer128)[0][u32((*&buffer130)[u32(unconst_u32(369))][7][6][u32(unconst_u32(253))][6])][50][u32(unconst_u32(136))];
  let vf78: vec4f = textureSampleBaseClampToEdge(tex42, sam10, vec2f(unconst_f32(0.1744), unconst_f32(0.06974)));
  out.f19 += vec4h(unpack4xU8(u32(unconst_u32(122))));
  out.f17 = bitcast<vec2f>((*ptr70)[0][1][u32(unconst_u32(283))][0].rb);
  return out;
}

@fragment
fn fragment4() -> FragmentOutput3 {
  var out: FragmentOutput3;
  out.f0 = unpack4xU8(u32(buffer131[u32(unconst_u32(30))][u32(unconst_u32(195))][2][0]));
  out.f1 = vec4u(textureSampleLevel(tex42, sam8, bitcast<vec2f>(textureLoad(tex43, vec2i(unconst_i32(31), unconst_i32(15)), i32(unconst_i32(153))).ga), f32(unconst_f32(0.2979)), clamp(vec2i(207, 137), vec2i(-8), vec2i(7))));
  let vf79: vec4f = textureSampleLevel(tex42, sam13, vec2f(unconst_f32(0.04760), unconst_f32(0.2503)), f32((*&buffer125)[2][22][0]), clamp(vec2i(248, 106), vec2i(-8), vec2i(7)));
  var vf80: vec4f = textureGather(tex35, sam10, vec2f(f32(buffer131[u32(unconst_u32(117))][1][u32(unconst_u32(40))][pack4x8unorm(textureGather(tex35, sam8, vec2f(unconst_f32(0.5485), unconst_f32(0.09793)), clamp(vec2i(16, 25), vec2i(-8), vec2i(7))))])), clamp(vec2i(83, 15), vec2i(-8), vec2i(7)));
  out.f3 = vec4f(textureDimensions(tex35).yyxx);
  vf80 += bitcast<vec4f>(textureDimensions(tex44).xyxx);
  out.f2 = vec4f(f32(buffer131[arrayLength(&buffer131)][1][u32(unconst_u32(203))][0]));
  out = FragmentOutput3(unpack4xU8(u32(buffer131[arrayLength(&buffer131)][1][2][u32(unconst_u32(182))])), vec4u(u32(buffer131[arrayLength(&buffer131)][1][2][u32(unconst_u32(182))])), vec4f(f32(buffer131[arrayLength(&buffer131)][1][2][u32(unconst_u32(182))])), vec4f(f32(buffer131[arrayLength(&buffer131)][1][2][u32(unconst_u32(182))])), f32(buffer131[arrayLength(&buffer131)][1][2][u32(unconst_u32(182))]), vec4f(f32(buffer131[arrayLength(&buffer131)][1][2][u32(unconst_u32(182))])));
  let ptr72: ptr<storage, array<f16, 1>, read_write> = &(*&buffer131)[arrayLength(&(*&buffer131))][u32(buffer127[u32(unconst_u32(333))])][2];
  out.f4 *= bitcast<f32>(pack4xU8Clamp(textureGather(81 % 4, tex43, sam8, vec2f(unconst_f32(0.1136), unconst_f32(0.1143)), clamp(vec2i(62, 184), vec2i(-8), vec2i(7)))));
  buffer125[2][u32(unconst_u32(20))][u32(unconst_u32(47))] += (*&buffer131)[arrayLength(&(*&buffer131))][1][2][0];
  let ptr73: ptr<storage, array<array<f16, 1>, 3>, read_write> = &(*&buffer131)[arrayLength(&(*&buffer131))][u32(unconst_u32(10))];
  out.f0 <<= unpack4xU8(u32((*&buffer131)[arrayLength(&(*&buffer131))][u32(unconst_u32(480))][2][0]));
  out.f4 *= f32((*&buffer131)[u32(unconst_u32(117))][u32(unconst_u32(40))][u32(unconst_u32(97))][0]);
  let ptr74: ptr<storage, f16, read_write> = &buffer125[u32(unconst_u32(370))][22][0];
  return out;
}

@compute @workgroup_size(2, 1, 1)
fn compute3(@builtin(workgroup_id) a0: vec3u, @builtin(num_workgroups) a1: vec3u, @builtin(global_invocation_id) a2: vec3u) {
  atomicCompareExchangeWeak(&buffer123[u32(unconst_u32(2))], unconst_i32(66), unconst_i32(425));
  let ptr75: ptr<storage, array<array<f16, 9>, 1>, read> = &(*&buffer124)[arrayLength(&(*&buffer124))][u32(unconst_u32(176))];
  let vf81: u32 = a0[u32(unconst_u32(110))];
  buffer133[u32(unconst_u32(150))] |= vec4i(i32((*&buffer125)[2][22][0]));
  textureStore(st13, i32(unconst_i32(137)), vec4u(vec4u(unconst_u32(189), unconst_u32(412), unconst_u32(664), unconst_u32(236))));
  let ptr76: ptr<storage, f16, read> = &buffer124[arrayLength(&buffer124)][u32(unconst_u32(32))][u32(unconst_u32(64))][u32(unconst_u32(171))];
  buffer125[u32(unconst_u32(55))][22][u32(unconst_u32(143))] = f16(textureGatherCompare(tex39, sam12, vec2f(unconst_f32(0.06813), unconst_f32(0.2957)), f32(unconst_f32(-0.1069)))[2]);
  buffer125[u32(unconst_u32(118))][u32(unconst_u32(25))][u32(unconst_u32(69))] = (*&buffer134)[u32(unconst_u32(50))][7][1][1][6][0];
  let ptr77: ptr<storage, f16, read> = &(*&buffer124)[arrayLength(&(*&buffer124))][u32(unconst_u32(31))][u32(unconst_u32(0))][8];
  let ptr78: ptr<storage, array<f16, 9>, read> = &(*&buffer124)[pack4xU8Clamp(bitcast<vec4u>(buffer133[i32(unconst_i32(237))]))][1][u32(unconst_u32(21))];
  atomicExchange(&buffer123[u32(unconst_u32(301))], i32(unconst_i32(57)));
  textureStore(st13, i32(unconst_i32(39)), vec4u(vec4u(unconst_u32(408), unconst_u32(68), unconst_u32(330), unconst_u32(90))));
  let vf82: vec2u = textureDimensions(tex34, i32(unconst_i32(90)));
  textureStore(st13, i32(unconst_i32(290)), vec4u(vec4u(unconst_u32(174), unconst_u32(81), unconst_u32(17), unconst_u32(307))));
  let ptr79: ptr<storage, f16, read_write> = &buffer125[u32((*&buffer124)[u32(unconst_u32(23))][1][0][u32(unconst_u32(196))])][u32(unconst_u32(402))][u32(unconst_u32(103))];
  textureStore(st13, i32(buffer134[u32(unconst_u32(32))][u32(unconst_u32(63))][u32(unconst_u32(89))][1][6][0]), vec4u(vec4u(unconst_u32(50), unconst_u32(108), unconst_u32(355), unconst_u32(18))));
  let ptr80: ptr<storage, f16, read> = &buffer134[u32(unconst_u32(84))][u32(unconst_u32(181))][u32(unconst_u32(150))][u32(unconst_u32(147))][6][0];
  textureStore(st13, i32(unconst_i32(151)), vec4u(vec4u(unconst_u32(209), unconst_u32(223), unconst_u32(258), unconst_u32(1))));
  let ptr81: ptr<storage, array<array<array<f16, 1>, 7>, 2>, read> = &buffer134[0][u32(unconst_u32(760))][u32(unconst_u32(5))];
  textureStore(st13, i32(unconst_i32(95)), vec4u(vec4u(unconst_u32(32), unconst_u32(68), unconst_u32(197), unconst_u32(200))));
  atomicAnd(&buffer123[u32(unconst_u32(199))], i32(unconst_i32(-123)));
  let ptr82: ptr<storage, f16, read> = &(*&buffer134)[0][7][1][u32(unconst_u32(118))][u32(unconst_u32(62))][u32(buffer134[0][u32(unconst_u32(553))][u32(unconst_u32(131))][u32(buffer124[u32(unconst_u32(493))][u32(unconst_u32(84))][u32(unconst_u32(187))][8])][6][0])];
}

@compute @workgroup_size(1, 1, 1)
fn compute4() {
  let ptr83: ptr<storage, array<f16, 9>, read> = &(*&buffer124)[u32(unconst_u32(99))][u32(unconst_u32(38))][0];
  let ptr84: ptr<storage, array<array<array<array<f16, 1>, 7>, 2>, 2>, read> = &buffer134[u32(unconst_u32(256))][7];
  let vf83: f32 = textureSampleCompareLevel(tex39, sam7, vec2f(unconst_f32(-0.00102), unconst_f32(0.08945)), f32(unconst_f32(0.1428)), clamp(vec2i(480, 5), vec2i(-8), vec2i(7)));
  let ptr85: ptr<storage, array<f16, 9>, read> = &buffer124[arrayLength(&buffer124)][u32(unconst_u32(192))][u32(unconst_u32(1))];
  let ptr86: ptr<storage, f16, read> = &(*&buffer134)[0][u32(unconst_u32(52))][1][u32(unconst_u32(5))][u32(unconst_u32(44))][u32(unconst_u32(70))];
  let ptr87: ptr<storage, array<array<f16, 1>, 23>, read_write> = &(*&buffer125)[u32(unconst_u32(112))];
  let ptr88: ptr<storage, f16, read> = &(*&buffer134)[u32(unconst_u32(118))][7][1][u32(unconst_u32(169))][u32(unconst_u32(40))][0];
  buffer133[u32(unconst_u32(169))] -= vec4i(i32((*&buffer134)[u32(unconst_u32(16))][u32(unconst_u32(405))][u32(unconst_u32(346))][1][6][0]));
  let ptr89: ptr<storage, array<array<f16, 1>, 7>, read> = &buffer134[u32(unconst_u32(202))][u32(unconst_u32(249))][u32(unconst_u32(41))][1];
  let ptr90: ptr<storage, array<array<f16, 1>, 23>, read_write> = &(*&buffer125)[u32(unconst_u32(136))];
  atomicCompareExchangeWeak(&buffer123[u32(unconst_u32(340))], unconst_i32(21), unconst_i32(292));
}`,
  sourceMap: {},
});
let bindGroupLayout24 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 46,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 197,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer135 = device0.createBuffer({size: 13905, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView201 = texture219.createView({label: '\u3eaa\u{1ffc6}\ue080'});
let texture221 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rg16uint', usage: GPUTextureUsage.COPY_SRC});
let textureView202 = texture17.createView({arrayLayerCount: 1});
try {
renderPassEncoder30.setIndexBuffer(buffer8, 'uint32', 2_036, 285);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(7, undefined, 0);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup57);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 645, height: 4, depthOrArrayLayers: 62}
*/
{
  source: videoFrame23,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture218,
  mipLevel: 1,
  origin: {x: 14, y: 0, z: 16},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder173 = device0.createCommandEncoder({});
let texture222 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 4},
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let texture223 = gpuCanvasContext3.getCurrentTexture();
let textureView203 = texture93.createView({});
try {
renderBundleEncoder24.setBindGroup(0, bindGroup90);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(7, buffer24, 0, 477);
} catch {}
try {
commandEncoder173.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 228 */
  offset: 216,
  bytesPerRow: 7424,
  buffer: buffer89,
}, {
  texture: texture92,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, {width: 6, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder173.clearBuffer(buffer4, 340, 20);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
document.body.prepend(img0);
let buffer136 = device0.createBuffer({
  size: 16858,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView204 = texture178.createView({mipLevelCount: 1});
let computePassEncoder142 = commandEncoder173.beginComputePass({});
let sampler98 = device0.createSampler({
  label: '\u0a93\ud106\ubdbb\ud777\u0df8',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 71.71,
  lodMaxClamp: 73.45,
});
try {
computePassEncoder92.setBindGroup(1, bindGroup29, new Uint32Array(8500), 163, 0);
} catch {}
try {
renderPassEncoder18.setScissorRect(3, 1, 11, 0);
} catch {}
try {
renderPassEncoder14.setStencilReference(875);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer18, 'uint16', 1_798, 3_732);
} catch {}
let buffer137 = device0.createBuffer({
  label: '\u303d\u50be\u1f49\u011b\u077c\u{1ff4e}',
  size: 6593,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder174 = device0.createCommandEncoder();
let textureView205 = texture79.createView({dimension: '2d', baseArrayLayer: 2});
try {
renderPassEncoder35.setBindGroup(3, bindGroup22);
} catch {}
try {
renderPassEncoder26.setBindGroup(3, bindGroup38, new Uint32Array(363), 24, 0);
} catch {}
try {
renderPassEncoder26.popDebugGroup();
} catch {}
let buffer138 = device0.createBuffer({size: 5385, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder175 = device0.createCommandEncoder({});
let texture224 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder104.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder48.setBindGroup(0, bindGroup6, new Uint32Array(351), 40, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup61);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(1, buffer40, 416, 526);
} catch {}
let imageData23 = new ImageData(52, 28);
let buffer139 = device0.createBuffer({
  size: 2097,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture225 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 22},
  format: 'rg32sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder143 = commandEncoder175.beginComputePass({});
let renderBundle24 = renderBundleEncoder24.finish({});
try {
renderPassEncoder9.setBindGroup(1, bindGroup14);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder174.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 468 */
  offset: 468,
  buffer: buffer36,
}, {
  texture: texture190,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer140 = device0.createBuffer({
  size: 3438,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let querySet24 = device0.createQuerySet({type: 'occlusion', count: 454});
let renderBundle25 = renderBundleEncoder25.finish({label: '\u8263\u8871\ubb50\u{1f683}\u{1f78b}\u{1ff8e}\u{1f988}\u8d9c'});
try {
renderPassEncoder8.beginOcclusionQuery(75);
} catch {}
try {
renderPassEncoder21.setStencilReference(705);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer119, 'uint16', 704, 385);
} catch {}
try {
commandEncoder174.copyTextureToTexture({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 273, y: 1, z: 54},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 58, y: 2, z: 1},
  aspect: 'all',
},
{width: 155, height: 0, depthOrArrayLayers: 4});
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let buffer141 = device0.createBuffer({
  size: 14927,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder144 = commandEncoder174.beginComputePass({});
try {
renderPassEncoder26.setBindGroup(3, bindGroup8);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
let textureView206 = texture58.createView({dimension: '2d', baseArrayLayer: 9});
let texture226 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 116},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder14.executeBundles([renderBundle0]);
} catch {}
let imageData24 = new ImageData(4, 8);
let buffer142 = device0.createBuffer({size: 11201, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder176 = device0.createCommandEncoder();
let textureView207 = texture225.createView({
  label: '\ub567\ubfde\u0546\u{1ff22}\u5b3c\ub3b0',
  baseMipLevel: 0,
  baseArrayLayer: 1,
  arrayLayerCount: 8,
});
try {
computePassEncoder102.setBindGroup(3, bindGroup91);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer24, 'uint16', 4_182, 3_838);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer99);
} catch {}
try {
buffer2.unmap();
} catch {}
let buffer143 = device0.createBuffer({
  label: '\u0a45\u{1fcba}\u8331\u8bc2\u0e75\u0241\u{1fe0d}\u4c38',
  size: 1988,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let textureView208 = texture219.createView({});
try {
computePassEncoder60.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle2, renderBundle0, renderBundle5]);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer36, 'uint32', 1_284, 188);
} catch {}
try {
buffer142.unmap();
} catch {}
try {
commandEncoder176.copyBufferToBuffer(buffer78, 6840, buffer49, 388, 296);
} catch {}
try {
commandEncoder176.copyTextureToTexture({
  texture: texture149,
  mipLevel: 0,
  origin: {x: 27, y: 2, z: 35},
  aspect: 'all',
},
{
  texture: texture60,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 41}
*/
{
  source: imageData19,
  origin: { x: 6, y: 5 },
  flipY: false,
}, {
  texture: texture204,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise17;
} catch {}
let computePassEncoder145 = commandEncoder176.beginComputePass({});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let externalTexture24 = device0.importExternalTexture({label: '\u8183\u0521\u{1ffc9}\u{1fc2e}\u{1fd9c}\u0fe6\u6732\ue3ac', source: videoFrame7});
try {
computePassEncoder40.setBindGroup(3, bindGroup8, new Uint32Array(1406), 13, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder18.setVertexBuffer(3, buffer22, 0, 3_391);
} catch {}
let imageData25 = new ImageData(64, 16);
let textureView209 = texture130.createView({mipLevelCount: 1, baseArrayLayer: 5, arrayLayerCount: 1});
let sampler99 = device0.createSampler({addressModeW: 'repeat', magFilter: 'nearest', minFilter: 'nearest', lodMaxClamp: 67.00});
try {
renderPassEncoder19.setBindGroup(3, bindGroup66);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer81, 'uint32', 492, 1_135);
} catch {}
let bindGroupLayout25 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 26,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 22,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let buffer144 = device0.createBuffer({
  size: 293,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView210 = texture174.createView({
  label: '\u04f2\ue6ba\ubf73\u6b37\u8145\u{1f9d0}\u3ca0\u{1fe53}\u{1f72f}\u79b4\u7a66',
  dimension: '2d',
  aspect: 'all',
  baseArrayLayer: 3,
});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], stencilReadOnly: true});
try {
computePassEncoder33.setBindGroup(1, bindGroup87, new Uint32Array(914), 191, 0);
} catch {}
try {
renderBundleEncoder27.setBindGroup(3, bindGroup41, new Uint32Array(1050), 435, 0);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer25, 'uint16', 114, 617);
} catch {}
let textureView211 = texture161.createView({dimension: 'cube'});
try {
renderPassEncoder10.setBindGroup(1, bindGroup66, new Uint32Array(2700), 10, 0);
} catch {}
let bindGroup96 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 245, resource: textureView121},
    {binding: 268, resource: textureView32},
    {binding: 296, resource: textureView210},
    {binding: 115, resource: textureView117},
    {binding: 107, resource: textureView143},
    {binding: 9, resource: {buffer: buffer6, offset: 4608, size: 1951}},
    {binding: 41, resource: {buffer: buffer136, offset: 6400, size: 816}},
    {binding: 38, resource: textureView43},
  ],
});
let buffer145 = device0.createBuffer({
  size: 12169,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView212 = texture90.createView({label: '\u67dc\u7e8d\u0255\u043e\u{1fe3a}', dimension: '2d', aspect: 'all', baseArrayLayer: 7});
let externalTexture25 = device0.importExternalTexture({source: videoFrame7});
try {
renderPassEncoder10.setBindGroup(1, bindGroup85);
} catch {}
try {
renderPassEncoder28.setBindGroup(3, bindGroup38, new Uint32Array(1588), 549, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture191,
  mipLevel: 0,
  origin: {x: 8, y: 26, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let buffer146 = device0.createBuffer({
  label: '\uf003\u0891\u0727\u25c0\u309b\ue6a6\u{1f92f}\u1e56\ue47f\u13fd',
  size: 797,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let textureView213 = texture62.createView({dimension: 'cube-array', format: 'rgba16uint', baseMipLevel: 0, baseArrayLayer: 5, arrayLayerCount: 18});
let texture227 = device0.createTexture({
  size: [110],
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle26 = renderBundleEncoder26.finish({});
try {
renderPassEncoder24.setBindGroup(3, bindGroup92, new Uint32Array(699), 170, 0);
} catch {}
try {
  await buffer51.mapAsync(GPUMapMode.READ, 0, 2344);
} catch {}
let bindGroup97 = device0.createBindGroup({
  label: '\u{1ff32}\ud07c\u02b1\u{1fd57}\u9e97\u7b98\u0f87\ud8b9\u{1f6c3}',
  layout: bindGroupLayout21,
  entries: [{binding: 219, resource: textureView61}],
});
let texture228 = device0.createTexture({
  size: [55, 8, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder123.setBindGroup(1, bindGroup97, new Uint32Array(935), 245, 0);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(6, buffer17, 0);
} catch {}
try {
renderBundleEncoder27.setBindGroup(3, bindGroup85);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(3, buffer145, 0, 702);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
await gc();
let texture229 = device0.createTexture({
  size: [13, 2, 1],
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundle27 = renderBundleEncoder27.finish();
try {
computePassEncoder86.setBindGroup(1, bindGroup33);
} catch {}
try {
renderPassEncoder28.setBindGroup(2, bindGroup14);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup21, new Uint32Array(189), 75, 0);
} catch {}
try {
renderPassEncoder26.end();
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle0, renderBundle5]);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder134.copyBufferToBuffer(buffer63, 944, buffer3, 100, 64);
} catch {}
let commandBuffer3 = commandEncoder134.finish();
try {
computePassEncoder51.setBindGroup(1, bindGroup55, []);
} catch {}
try {
computePassEncoder127.setBindGroup(1, bindGroup19, new Uint32Array(495), 5, 0);
} catch {}
try {
renderPassEncoder32.setBindGroup(3, bindGroup92, new Uint32Array(1938), 390, 0);
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle27, renderBundle27]);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
buffer44.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas3);
let commandEncoder177 = device0.createCommandEncoder();
try {
computePassEncoder64.setBindGroup(0, bindGroup31);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup26);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer87, 'uint32', 436, 744);
} catch {}
try {
buffer36.unmap();
} catch {}
let bindGroup98 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 190, resource: textureView142},
    {binding: 160, resource: textureView53},
    {binding: 70, resource: textureView141},
    {binding: 110, resource: textureView144},
    {binding: 349, resource: sampler79},
    {binding: 185, resource: textureView3},
    {binding: 351, resource: {buffer: buffer52, offset: 0, size: 46}},
    {binding: 252, resource: {buffer: buffer43, offset: 0, size: 244}},
    {binding: 79, resource: {buffer: buffer44, offset: 3840, size: 5016}},
    {binding: 8, resource: textureView37},
    {binding: 195, resource: textureView6},
    {binding: 255, resource: {buffer: buffer92, offset: 2560, size: 236}},
    {binding: 12, resource: {buffer: buffer49, offset: 256}},
    {binding: 68, resource: {buffer: buffer140, offset: 256, size: 2451}},
    {binding: 306, resource: textureView75},
    {binding: 14, resource: {buffer: buffer75, offset: 256, size: 16023}},
    {binding: 47, resource: textureView177},
    {binding: 163, resource: sampler19},
    {binding: 44, resource: sampler14},
    {binding: 0, resource: {buffer: buffer44, offset: 2048, size: 6392}},
    {binding: 143, resource: {buffer: buffer95, offset: 4352, size: 328}},
    {binding: 523, resource: textureView169},
    {binding: 177, resource: textureView1},
    {binding: 287, resource: textureView151},
    {binding: 88, resource: textureView79},
    {binding: 6, resource: textureView179},
    {binding: 196, resource: textureView151},
    {binding: 389, resource: textureView140},
  ],
});
let commandEncoder178 = device0.createCommandEncoder({});
let computePassEncoder146 = commandEncoder178.beginComputePass({});
try {
renderPassEncoder30.setBindGroup(1, bindGroup79, new Uint32Array(781), 318, 0);
} catch {}
try {
renderPassEncoder15.setScissorRect(3, 4, 21, 5);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(0, buffer31, 1_188);
} catch {}
try {
buffer138.unmap();
} catch {}
try {
commandEncoder177.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3304 */
  offset: 3304,
  buffer: buffer11,
}, {
  texture: texture191,
  mipLevel: 1,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
}, {width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
let querySet25 = device0.createQuerySet({type: 'occlusion', count: 207});
let texture230 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_DST});
let renderPassEncoder37 = commandEncoder177.beginRenderPass({
  colorAttachments: [{
  view: textureView94,
  clearValue: { r: -379.9, g: 494.1, b: 596.0, a: -471.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet14,
});
try {
computePassEncoder82.setBindGroup(3, bindGroup49, new Uint32Array(5848), 735, 0);
} catch {}
try {
adapter0.label = '\u502d\u{1ffd8}\ucb34\u{1fc01}';
} catch {}
let texture231 = device0.createTexture({
  label: '\u0902\u5cd2\u0b11\uc158\u0fe9\u6b03',
  size: [1290, 8, 9],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler100 = device0.createSampler({
  label: '\ucf70\u0703\u0296\u099e',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 43.52,
  lodMaxClamp: 97.79,
  compare: 'less',
});
let externalTexture26 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
computePassEncoder127.setBindGroup(1, bindGroup89, new Uint32Array(432), 56, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder34.setBindGroup(2, bindGroup55, new Uint32Array(1470), 71, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer30, 1208, new DataView(new ArrayBuffer(10435)), 295, 840);
} catch {}
let buffer147 = device0.createBuffer({size: 5490, usage: GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let sampler101 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 11.71,
  lodMaxClamp: 56.15,
  maxAnisotropy: 18,
});
try {
renderPassEncoder32.setScissorRect(24, 1, 6, 0);
} catch {}
let commandEncoder179 = device0.createCommandEncoder({});
let texture232 = device0.createTexture({size: {width: 645}, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder93.setBindGroup(2, bindGroup20, []);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup75, new Uint32Array(1437), 128, 0);
} catch {}
try {
commandEncoder179.copyTextureToBuffer({
  texture: texture136,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 886 */
  offset: 886,
  bytesPerRow: 7680,
  buffer: buffer97,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas2);
let buffer148 = device0.createBuffer({
  label: '\udf60\u09b9',
  size: 13385,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
let commandEncoder180 = device0.createCommandEncoder({});
try {
computePassEncoder120.setBindGroup(1, bindGroup16);
} catch {}
try {
commandEncoder179.copyBufferToTexture({
  /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 456 */
  offset: 456,
  bytesPerRow: 1792,
  buffer: buffer9,
}, {
  texture: texture153,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup99 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 134, resource: textureView78},
    {binding: 156, resource: textureView65},
    {binding: 0, resource: textureView4},
    {binding: 319, resource: externalTexture3},
    {binding: 108, resource: {buffer: buffer5, offset: 0}},
    {binding: 66, resource: textureView187},
    {binding: 495, resource: {buffer: buffer136, offset: 5888, size: 788}},
    {binding: 25, resource: {buffer: buffer98, offset: 512, size: 979}},
    {binding: 58, resource: textureView61},
    {binding: 268, resource: textureView141},
    {binding: 189, resource: textureView155},
    {binding: 72, resource: {buffer: buffer28, offset: 1792, size: 540}},
    {binding: 8, resource: {buffer: buffer3, offset: 0, size: 96}},
    {binding: 207, resource: textureView55},
  ],
});
let commandEncoder181 = device0.createCommandEncoder();
let textureView214 = texture160.createView({dimension: '2d-array', aspect: 'all'});
let computePassEncoder147 = commandEncoder179.beginComputePass({});
let sampler102 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 17.68,
  maxAnisotropy: 11,
});
try {
renderPassEncoder30.setBindGroup(2, bindGroup1, new Uint32Array(4804), 3_716, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer78, 0, 7_936);
} catch {}
try {
commandEncoder180.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1660 */
  offset: 1660,
  buffer: buffer2,
}, {
  texture: texture30,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture167,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = texture13.label;
} catch {}
let bindGroup100 = device0.createBindGroup({layout: bindGroupLayout18, entries: [{binding: 43, resource: textureView76}]});
let buffer149 = device0.createBuffer({size: 17366, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture233 = device0.createTexture({
  size: [52, 40, 34],
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView215 = texture0.createView({baseMipLevel: 0, baseArrayLayer: 0});
let computePassEncoder148 = commandEncoder181.beginComputePass({});
try {
renderPassEncoder20.setIndexBuffer(buffer16, 'uint16', 1_198, 453);
} catch {}
try {
commandEncoder180.copyBufferToBuffer(buffer103, 168, buffer139, 492, 440);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: imageData12,
  origin: { x: 6, y: 23 },
  flipY: false,
}, {
  texture: texture191,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let buffer150 = device0.createBuffer({size: 6136, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let renderPassEncoder38 = commandEncoder180.beginRenderPass({colorAttachments: [{view: textureView68, loadOp: 'clear', storeOp: 'store'}]});
try {
computePassEncoder69.setBindGroup(1, bindGroup20, new Uint32Array(1377), 428, 0);
} catch {}
let commandEncoder182 = device0.createCommandEncoder();
let textureView216 = texture133.createView({mipLevelCount: 1});
let computePassEncoder149 = commandEncoder182.beginComputePass({});
let sampler103 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 92.14,
  compare: 'less',
});
try {
computePassEncoder35.setBindGroup(0, bindGroup58, new Uint32Array(6662), 191, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup4);
} catch {}
let buffer151 = device0.createBuffer({size: 5835, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let textureView217 = texture58.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 7});
let sampler104 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 56.43,
  maxAnisotropy: 11,
});
try {
renderPassEncoder24.setIndexBuffer(buffer35, 'uint32', 264, 306);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
}, new Uint8Array(6_529).fill(65), /* required buffer size: 6_529 */
{offset: 319, bytesPerRow: 135, rowsPerImage: 46}, {width: 0, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); };
} catch {}
let texture234 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler105 = device0.createSampler({
  label: '\u0322\u9333\u6fb9\uf0aa\u{1fad8}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 23.40,
  lodMaxClamp: 66.42,
  compare: 'never',
});
try {
computePassEncoder79.setBindGroup(0, bindGroup13);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup80);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup5, new Uint32Array(123), 11, 0);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle4, renderBundle14]);
} catch {}
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder183 = device0.createCommandEncoder({});
let texture235 = device0.createTexture({size: [2, 2, 27], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
let textureView218 = texture15.createView({mipLevelCount: 1});
let computePassEncoder150 = commandEncoder183.beginComputePass({});
try {
renderPassEncoder12.setBindGroup(1, bindGroup93, new Uint32Array(2685), 884, 0);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(6, buffer37);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 14},
  aspect: 'all',
}, new Uint8Array(442_272).fill(171), /* required buffer size: 442_272 */
{offset: 48, bytesPerRow: 74, rowsPerImage: 83}, {width: 0, height: 0, depthOrArrayLayers: 73});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let bindGroupLayout26 = device0.createBindGroupLayout({
  label: '\uf3d5\u0af7\u7724\ue62a\u0537\u7319\uee04\u{1fad5}',
  entries: [
    {
      binding: 76,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let texture236 = gpuCanvasContext6.getCurrentTexture();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 15}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData26 = new ImageData(92, 88);
let textureView219 = texture86.createView({});
try {
computePassEncoder86.setBindGroup(2, bindGroup63);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup65);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle4]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame4,
  origin: { x: 54, y: 24 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout27 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 30,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let bindGroup101 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 351, resource: {buffer: buffer25, offset: 0, size: 444}},
    {binding: 44, resource: sampler92},
    {binding: 195, resource: textureView177},
    {binding: 389, resource: textureView198},
    {binding: 68, resource: {buffer: buffer140, offset: 256, size: 322}},
    {binding: 185, resource: textureView110},
    {binding: 6, resource: textureView76},
    {binding: 190, resource: textureView146},
    {binding: 70, resource: textureView179},
    {binding: 287, resource: textureView55},
    {binding: 196, resource: textureView135},
    {binding: 12, resource: {buffer: buffer136, offset: 256, size: 1912}},
    {binding: 177, resource: textureView3},
    {binding: 88, resource: textureView191},
    {binding: 160, resource: textureView150},
    {binding: 14, resource: {buffer: buffer10, offset: 9728, size: 566}},
    {binding: 110, resource: textureView92},
    {binding: 252, resource: {buffer: buffer61, offset: 5888, size: 1344}},
    {binding: 143, resource: {buffer: buffer77, offset: 1280, size: 1998}},
    {binding: 306, resource: textureView90},
    {binding: 523, resource: textureView163},
    {binding: 163, resource: sampler41},
    {binding: 79, resource: {buffer: buffer13, offset: 0, size: 3116}},
    {binding: 255, resource: {buffer: buffer29, offset: 6400}},
    {binding: 0, resource: {buffer: buffer5, offset: 1280, size: 3012}},
    {binding: 47, resource: textureView177},
    {binding: 8, resource: textureView201},
    {binding: 349, resource: sampler13},
  ],
});
let commandEncoder184 = device0.createCommandEncoder({});
let computePassEncoder151 = commandEncoder184.beginComputePass();
try {
renderPassEncoder24.setBindGroup(1, bindGroup24, new Uint32Array(1060), 97, 0);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(5, buffer138);
} catch {}
let textureView220 = texture23.createView({arrayLayerCount: 2});
try {
renderPassEncoder32.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder29.setViewport(22.69157646445378, 17.72014872489379, 16.765546413472833, 17.361844504619686, 0.38174902618140505, 0.7512847957853781);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(4, buffer31);
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let canvas5 = document.createElement('canvas');
let texture237 = device0.createTexture({
  label: '\u796d\u0e5a\u6838\u06e6\u{1fd72}\u9165\u94b7\ueaff',
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let texture238 = gpuCanvasContext1.getCurrentTexture();
try {
renderPassEncoder38.setIndexBuffer(buffer31, 'uint32', 744, 540);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(3, buffer15, 316, 470);
} catch {}
try {
buffer57.unmap();
} catch {}
let offscreenCanvas4 = new OffscreenCanvas(52, 188);
let buffer152 = device0.createBuffer({
  size: 35643,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder58.setBindGroup(3, bindGroup18, new Uint32Array(89), 7, 0);
} catch {}
try {
renderPassEncoder32.endOcclusionQuery();
} catch {}
try {
renderPassEncoder17.setVertexBuffer(6, buffer64);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData27 = new ImageData(48, 24);
let bindGroup102 = device0.createBindGroup({
  label: '\u43bb\u{1fa9b}\uf98a\u040a\uf23b\ud286\u0dbe\u7320\ubd6a\u5f33\u0ee9',
  layout: bindGroupLayout8,
  entries: [{binding: 31, resource: textureView213}],
});
let texture239 = device0.createTexture({
  size: [13, 2, 26],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView221 = texture21.createView({dimension: '2d', baseArrayLayer: 19});
try {
renderPassEncoder31.setBindGroup(1, bindGroup8, []);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle1, renderBundle4]);
} catch {}
try {
device0.queue.writeBuffer(buffer146, 140, new Int16Array(3664), 888, 252);
} catch {}
let buffer153 = device0.createBuffer({
  label: '\u0d7d\u9c9e\ua6cb\u1dba',
  size: 16637,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
try {
device0.queue.writeTexture({
  texture: texture151,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(154).fill(127), /* required buffer size: 154 */
{offset: 154, bytesPerRow: 143}, {width: 6, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.prepend(img0);
let commandEncoder185 = device0.createCommandEncoder();
let textureView222 = texture199.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1});
let computePassEncoder152 = commandEncoder185.beginComputePass({});
try {
computePassEncoder32.setBindGroup(0, bindGroup55);
} catch {}
try {
computePassEncoder77.setBindGroup(1, bindGroup58, new Uint32Array(1908), 368, 0);
} catch {}
try {
computePassEncoder90.end();
} catch {}
try {
renderPassEncoder31.setVertexBuffer(6, buffer40, 0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeBuffer(buffer146, 44, new BigUint64Array(1835), 193, 4);
} catch {}
let texture240 = device0.createTexture({
  size: {width: 27},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder153 = commandEncoder108.beginComputePass({});
try {
computePassEncoder2.setBindGroup(2, bindGroup78);
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup20, new Uint32Array(974), 132, 0);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer64, 4, 32);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: canvas2,
  origin: { x: 457, y: 6 },
  flipY: false,
}, {
  texture: texture238,
  mipLevel: 0,
  origin: {x: 2, y: 41, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 22, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); };
} catch {}
let imageData28 = new ImageData(16, 24);
let textureView223 = texture191.createView({
  label: '\u2279\u30bb\u{1fc7b}\u4023\u0d89\u2cca\uf58d\u5708\u0b8f\u{1f654}\u0fdd',
  dimension: '2d-array',
  mipLevelCount: 1,
});
try {
computePassEncoder110.setBindGroup(2, bindGroup63, []);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer39, 'uint32', 1_492, 1_337);
} catch {}
let textureView224 = texture13.createView({mipLevelCount: 1});
try {
renderPassEncoder8.setViewport(7.125304749671084, 5.231511855225488, 7.718625443366023, 7.926098949728885, 0.6895704781691725, 0.9248467714252196);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(1, buffer122);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 5, y: 8, z: 0},
  aspect: 'all',
}, new Uint8Array(1).fill(32), /* required buffer size: 1 */
{offset: 1, bytesPerRow: 121}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
offscreenCanvas4.getContext('webgl');
} catch {}
let buffer154 = device0.createBuffer({
  size: 41694,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder134.setBindGroup(2, bindGroup51);
} catch {}
try {
renderPassEncoder28.setBindGroup(2, bindGroup1);
} catch {}
let arrayBuffer13 = buffer100.getMappedRange(1136, 948);
let bindGroup103 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 31, resource: textureView67}]});
let texture241 = device0.createTexture({
  size: [161, 1, 15],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler106 = device0.createSampler({
  label: '\u481e\ue9f2\uac02\u6878\u4254\uc811',
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 29.56,
  lodMaxClamp: 82.47,
});
try {
renderPassEncoder23.setBindGroup(1, bindGroup4, []);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer16, 'uint16', 2, 7_739);
} catch {}
try {
computePassEncoder69.setBindGroup(0, bindGroup31, []);
} catch {}
try {
computePassEncoder119.setBindGroup(3, bindGroup88, new Uint32Array(5234), 606, 0);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle18]);
} catch {}
try {
buffer51.unmap();
} catch {}
let buffer155 = device0.createBuffer({size: 441, usage: GPUBufferUsage.MAP_READ});
let commandEncoder186 = device0.createCommandEncoder();
let computePassEncoder154 = commandEncoder186.beginComputePass({});
try {
renderPassEncoder24.setBlendConstant({ r: -499.2, g: -491.5, b: 756.1, a: -279.9, });
} catch {}
try {
buffer12.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture238,
  mipLevel: 0,
  origin: {x: 14, y: 9, z: 0},
  aspect: 'all',
}, new Uint8Array(94).fill(56), /* required buffer size: 94 */
{offset: 94, bytesPerRow: 761}, {width: 182, height: 6, depthOrArrayLayers: 0});
} catch {}
let buffer156 = device0.createBuffer({
  size: 24567,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder187 = device0.createCommandEncoder();
let querySet26 = device0.createQuerySet({type: 'occlusion', count: 1113});
let texture242 = device0.createTexture({
  size: [110, 16, 45],
  mipLevelCount: 2,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView225 = texture129.createView({baseArrayLayer: 0});
let sampler107 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.32,
  maxAnisotropy: 12,
});
try {
computePassEncoder36.setBindGroup(2, bindGroup58, new Uint32Array(2165), 403, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer156, 8488, new Float32Array(1139), 509, 108);
} catch {}
try {
adapter0.label = '\uaff2\u{1fed7}\u05d3\u{1fe07}';
} catch {}
try {
externalTexture8.label = '\u9268\u0da3\u{1fa80}\ue60d\u0cb8';
} catch {}
let bindGroup104 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [
    {binding: 46, resource: textureView219},
    {binding: 197, resource: {buffer: buffer49, offset: 2816, size: 888}},
  ],
});
let commandEncoder188 = device0.createCommandEncoder({});
let textureView226 = texture165.createView({arrayLayerCount: 16});
try {
computePassEncoder6.setBindGroup(0, bindGroup30);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer3, 0, 30);
} catch {}
try {
commandEncoder187.resolveQuerySet(querySet9, 74, 50, buffer15, 256);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture87,
  mipLevel: 1,
  origin: {x: 52, y: 0, z: 9},
  aspect: 'all',
}, new Uint8Array(277).fill(64), /* required buffer size: 277 */
{offset: 277, rowsPerImage: 59}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder189 = device0.createCommandEncoder();
let querySet27 = device0.createQuerySet({type: 'occlusion', count: 72});
let computePassEncoder155 = commandEncoder187.beginComputePass({label: '\u5a83\u4afb\u8c54\u{1fd83}\u0c25\u0224\uf85a\u4c25\u9f77\u0b0e\u0588'});
let renderPassEncoder39 = commandEncoder189.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  clearValue: { r: 716.4, g: -174.0, b: 861.7, a: 835.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder46.setBindGroup(0, bindGroup32);
} catch {}
try {
computePassEncoder18.setBindGroup(0, bindGroup90, new Uint32Array(1950), 301, 0);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer72, 'uint16', 1_388, 4_644);
} catch {}
try {
commandEncoder188.copyBufferToTexture({
  /* bytesInLastRow: 264 widthInBlocks: 66 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3676 */
  offset: 3676,
  bytesPerRow: 56832,
  rowsPerImage: 673,
  buffer: buffer103,
}, {
  texture: texture238,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
}, {width: 66, height: 30, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder188.copyTextureToBuffer({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4508 */
  offset: 4508,
  bytesPerRow: 17920,
  buffer: buffer54,
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let bindGroupLayout28 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 423,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let computePassEncoder156 = commandEncoder188.beginComputePass({});
let sampler108 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 54.79,
  lodMaxClamp: 86.43,
});
try {
computePassEncoder65.setBindGroup(2, bindGroup11, new Uint32Array(1713), 35, 0);
} catch {}
let arrayBuffer14 = buffer100.getMappedRange(168, 40);
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let promise18 = device0.queue.onSubmittedWorkDone();
let bindGroup105 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [
    {binding: 46, resource: textureView138},
    {binding: 197, resource: {buffer: buffer77, offset: 1280, size: 1996}},
  ],
});
let buffer157 = device0.createBuffer({
  size: 2605,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder190 = device0.createCommandEncoder({});
let texture243 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 57},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let computePassEncoder157 = commandEncoder190.beginComputePass({});
try {
computePassEncoder118.setBindGroup(2, bindGroup91);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle17, renderBundle2, renderBundle1]);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer75, 'uint32', 5_336, 480);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let bindGroup106 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 219, resource: textureView211}]});
let commandEncoder191 = device0.createCommandEncoder({});
try {
computePassEncoder21.setBindGroup(1, bindGroup32);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup18, new Uint32Array(814), 247, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer78, 'uint16', 148, 6_090);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer77, 36, new Int16Array(17336), 4413, 324);
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'unspecified', transfer: 'smpteSt4281'} });
let bindGroup107 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView133}]});
let computePassEncoder158 = commandEncoder191.beginComputePass({label: '\u7863\u5f09\u{1f68f}\u0f14\ubb95\u299c\u{1f7d7}\u90ef\uceb6\u0a4f\uc1d6'});
try {
computePassEncoder130.setBindGroup(0, bindGroup104, new Uint32Array(3774), 455, 0);
} catch {}
try {
  await promise18;
} catch {}
document.body.prepend(canvas3);
let texture244 = device0.createTexture({
  label: '\u0879\u091d\u4c1b\u{1fcdf}\u08d9\u530f\ue182\udaa2\u7423\u{1ffce}',
  size: {width: 161, height: 1, depthOrArrayLayers: 15},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView227 = texture229.createView({dimension: '2d-array'});
try {
computePassEncoder37.setBindGroup(0, bindGroup61);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle4]);
} catch {}
let imageData29 = new ImageData(64, 4);
let buffer158 = device0.createBuffer({
  size: 8655,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView228 = texture170.createView({baseArrayLayer: 0, arrayLayerCount: 1});
let textureView229 = texture140.createView({label: '\ue1e3\u0205\u03c9\u31df\u5be0\u{1fd57}\u0ca7\u{1f6f1}\u34f5', dimension: '1d'});
let sampler109 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 55.42,
  lodMaxClamp: 65.04,
});
try {
renderPassEncoder15.setIndexBuffer(buffer30, 'uint16', 226, 815);
} catch {}
let bindGroup108 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 124, resource: textureView42},
    {binding: 112, resource: sampler0},
    {binding: 29, resource: textureView41},
    {binding: 136, resource: textureView36},
    {binding: 7, resource: textureView197},
  ],
});
let commandEncoder192 = device0.createCommandEncoder({});
let computePassEncoder159 = commandEncoder192.beginComputePass({});
let texture245 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 29},
  mipLevelCount: 6,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture246 = gpuCanvasContext3.getCurrentTexture();
let textureView230 = texture228.createView({});
try {
renderPassEncoder27.setStencilReference(160);
} catch {}
try {
computePassEncoder153.setBindGroup(1, bindGroup21, new Uint32Array(136), 7, 0);
} catch {}
try {
renderPassEncoder33.executeBundles([renderBundle27]);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(6, buffer77, 3_212, 112);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer159 = device0.createBuffer({
  label: '\ud117\u{1ff29}',
  size: 159,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder193 = device0.createCommandEncoder();
let sampler110 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 7.613,
  lodMaxClamp: 9.932,
  compare: 'greater-equal',
  maxAnisotropy: 18,
});
try {
computePassEncoder129.setBindGroup(0, bindGroup35);
} catch {}
try {
computePassEncoder119.setBindGroup(1, bindGroup102, new Uint32Array(2791), 845, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup39);
} catch {}
try {
renderPassEncoder0.setStencilReference(55);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 2, depthOrArrayLayers: 41}
*/
{
  source: offscreenCanvas4,
  origin: { x: 4, y: 5 },
  flipY: false,
}, {
  texture: texture204,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData30 = new ImageData(16, 24);
try {
externalTexture12.label = '\ub49b\u9a52\u0b19';
} catch {}
let bindGroup109 = device0.createBindGroup({layout: bindGroupLayout15, entries: [{binding: 61, resource: textureView168}]});
let commandEncoder194 = device0.createCommandEncoder({label: '\u7e27\u62d2\u{1fcf8}\u2f7d\u0516\ube61\u8955\u7280\u{1f801}'});
let computePassEncoder160 = commandEncoder193.beginComputePass({});
try {
computePassEncoder15.setBindGroup(2, bindGroup86, new Uint32Array(1147), 157, 0);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup25, new Uint32Array(14), 1, 0);
} catch {}
let bindGroup110 = device0.createBindGroup({
  label: '\u85a4\u0d34\u04e5\u0486\u0d21\ub5a5',
  layout: bindGroupLayout22,
  entries: [
    {binding: 440, resource: sampler25},
    {binding: 92, resource: textureView195},
    {binding: 594, resource: textureView100},
    {binding: 46, resource: textureView141},
    {binding: 5, resource: textureView179},
  ],
});
let querySet28 = device0.createQuerySet({type: 'occlusion', count: 91});
let computePassEncoder161 = commandEncoder194.beginComputePass({});
try {
renderPassEncoder38.setBindGroup(0, bindGroup48, new Uint32Array(2610), 1_439, 0);
} catch {}
let bindGroup111 = device0.createBindGroup({
  label: '\u7f7b\u3741\ue306\u02a3\u3bd5\u1a5b\u{1fe55}\uaff3\u740a\u{1f830}',
  layout: bindGroupLayout20,
  entries: [{binding: 259, resource: {buffer: buffer118, offset: 256}}, {binding: 27, resource: sampler18}],
});
let buffer160 = device0.createBuffer({label: '\ud98b\ucc03', size: 1914, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView231 = texture132.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder149.setBindGroup(1, bindGroup106, new Uint32Array(11), 0, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder2.setScissorRect(12, 3, 6, 3);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(4, buffer55, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture90,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 5},
  aspect: 'all',
}, new Uint8Array(591).fill(53), /* required buffer size: 591 */
{offset: 591, rowsPerImage: 112}, {width: 22, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter0.label = '\u7779\u69f6';
} catch {}
let buffer161 = device0.createBuffer({size: 15033, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView232 = texture99.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 10});
let sampler111 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 84.52,
  lodMaxClamp: 87.74,
});
try {
renderPassEncoder20.setIndexBuffer(buffer11, 'uint32', 1_832, 92);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(3, buffer2);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 27}
*/
{
  source: imageData7,
  origin: { x: 0, y: 15 },
  flipY: true,
}, {
  texture: texture205,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder195 = device0.createCommandEncoder({});
let querySet29 = device0.createQuerySet({type: 'occlusion', count: 658});
let textureView233 = texture28.createView({dimension: '2d-array', format: 'depth24plus-stencil8'});
try {
computePassEncoder91.setBindGroup(2, bindGroup88);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(137);
} catch {}
try {
commandEncoder195.copyTextureToTexture({
  texture: texture119,
  mipLevel: 0,
  origin: {x: 62, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture47,
  mipLevel: 0,
  origin: {x: 156, y: 0, z: 0},
  aspect: 'all',
},
{width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let imageData31 = new ImageData(72, 12);
let buffer162 = device0.createBuffer({size: 4543, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let textureView234 = texture62.createView({
  label: '\u3175\ufe20\u31d3\uf9a8\u051d',
  dimension: 'cube-array',
  baseArrayLayer: 2,
  arrayLayerCount: 6,
});
let texture247 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder162 = commandEncoder195.beginComputePass({});
let sampler112 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 65.27,
  lodMaxClamp: 82.94,
});
try {
renderPassEncoder30.setBindGroup(0, bindGroup64, new Uint32Array(295), 41, 0);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer72, 'uint16', 424, 207);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(5, buffer82, 2_948);
} catch {}
canvas4.height = 81;
try {
canvas5.getContext('webgl2');
} catch {}
let bindGroupLayout29 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 166,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
  ],
});
let sampler113 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.29,
  maxAnisotropy: 5,
});
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.setStencilReference(532);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(2, buffer66, 2_008);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let buffer163 = device0.createBuffer({size: 1416, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder196 = device0.createCommandEncoder({});
let querySet30 = device0.createQuerySet({
  label: '\u0514\u9609\u071f\u{1fc77}\u3818\u{1fd83}\u7ca7\ud921\ua2ad\u046b',
  type: 'occlusion',
  count: 497,
});
let computePassEncoder163 = commandEncoder196.beginComputePass();
try {
renderPassEncoder7.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle7]);
} catch {}
let sampler114 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 17.07,
  lodMaxClamp: 48.67,
  maxAnisotropy: 2,
});
try {
computePassEncoder160.setBindGroup(2, bindGroup56, new Uint32Array(572), 15, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer84, 'uint32', 4_316, 5_867);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(56).fill(18), /* required buffer size: 56 */
{offset: 56}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder197 = device0.createCommandEncoder({});
let computePassEncoder164 = commandEncoder197.beginComputePass({label: '\u54d1\u65e0'});
try {
renderPassEncoder16.setIndexBuffer(buffer80, 'uint32', 528, 735);
} catch {}
let commandEncoder198 = device0.createCommandEncoder({});
let texture248 = device0.createTexture({
  size: [26, 20, 16],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView235 = texture107.createView({baseArrayLayer: 2, arrayLayerCount: 7});
try {
renderPassEncoder33.setBindGroup(2, bindGroup100, new Uint32Array(1251), 24, 0);
} catch {}
try {
buffer98.unmap();
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
});
} catch {}
let commandEncoder199 = device0.createCommandEncoder();
let textureView236 = texture170.createView({label: '\u07e9\u0fd8\u{1fe1c}\ua534\u00a4\u7fa0\u05c1\u{1f9e7}', dimension: '2d-array'});
try {
computePassEncoder4.setBindGroup(1, bindGroup28);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup0, new Uint32Array(1073), 453, 0);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer16, 'uint32', 1_560, 2_340);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let textureView237 = texture50.createView({});
try {
computePassEncoder89.setBindGroup(1, bindGroup22);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas3);
let videoFrame28 = new VideoFrame(imageBitmap4, {timestamp: 0});
let textureView238 = texture80.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 21});
try {
renderPassEncoder3.setBindGroup(1, bindGroup61, new Uint32Array(818), 49, 0);
} catch {}
try {
renderPassEncoder24.setViewport(40.93532391835359, 17.76052909307051, 7.264907014070628, 5.0109183593419475, 0.6189656257578285, 0.7561299298665112);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(3, buffer89, 0, 6_214);
} catch {}
try {
buffer28.unmap();
} catch {}
try {
commandEncoder198.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 6624 */
  offset: 6624,
  bytesPerRow: 7424,
  buffer: buffer149,
}, {
  texture: texture76,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas2);
let buffer164 = device0.createBuffer({
  label: '\u{1fa90}\u8f28\u002c\u05bb',
  size: 5258,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView239 = texture143.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
let computePassEncoder165 = commandEncoder199.beginComputePass();
let sampler115 = device0.createSampler({
  label: '\u0d62\ub4ca\u0ad1\u0e21\u14c3\u064b\uf5bd\u99a1\u0179\ub2cf\u7f01',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 91.97,
  lodMaxClamp: 97.50,
  maxAnisotropy: 5,
});
try {
renderPassEncoder32.executeBundles([renderBundle27]);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer84, 'uint32', 1_412, 5_403);
} catch {}
try {
buffer34.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer29, 1084, new DataView(new ArrayBuffer(8608)));
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: imageData21,
  origin: { x: 0, y: 2 },
  flipY: false,
}, {
  texture: texture191,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 2, height: 10, depthOrArrayLayers: 0});
} catch {}
let bindGroup112 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView14}]});
let commandEncoder200 = device0.createCommandEncoder({label: '\u8ea1\ufe03\u{1fd3a}\ucc51\u0a00\u0a8e\u{1f8fe}\u00fb\u0d09\uac4d\ub6cc'});
let querySet31 = device0.createQuerySet({type: 'occlusion', count: 934});
let textureView240 = texture130.createView({aspect: 'all', baseArrayLayer: 8, arrayLayerCount: 3});
let computePassEncoder166 = commandEncoder198.beginComputePass({});
try {
renderPassEncoder12.setBindGroup(3, bindGroup76);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer40, 'uint32', 428, 495);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(4, buffer159, 0, 86);
} catch {}
try {
commandEncoder200.copyBufferToBuffer(buffer96, 584, buffer28, 3008, 4);
} catch {}
let bindGroup113 = device0.createBindGroup({layout: bindGroupLayout26, entries: [{binding: 76, resource: textureView220}]});
let commandEncoder201 = device0.createCommandEncoder({label: '\u95c5\u0b74'});
try {
renderPassEncoder29.setVertexBuffer(4, buffer61, 0);
} catch {}
let pipeline1 = device0.createRenderPipeline({
  label: '\ue80e\u0174\u{1f685}\u{1fbe9}\u02bd\u00a7\u0962\u0dbe',
  layout: pipelineLayout6,
  fragment: {
  module: shaderModule3,
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {arrayStride: 0, stepMode: 'vertex', attributes: [{format: 'uint8x4', offset: 612, shaderLocation: 7}]},
    ],
  },
});
let commandEncoder202 = device0.createCommandEncoder({});
let renderPassEncoder40 = commandEncoder201.beginRenderPass({
  colorAttachments: [{
  view: textureView144,
  clearValue: { r: 796.2, g: 910.3, b: -298.9, a: 785.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder154.setBindGroup(2, bindGroup36);
} catch {}
try {
computePassEncoder75.setBindGroup(0, bindGroup29, new Uint32Array(7175), 123, 0);
} catch {}
let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'smpte170m'} });
let bindGroup114 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 90, resource: externalTexture22}, {binding: 348, resource: textureView0}],
});
let textureView241 = texture170.createView({dimension: '2d-array', mipLevelCount: 1});
let texture249 = gpuCanvasContext0.getCurrentTexture();
let sampler116 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.90,
  compare: 'less',
  maxAnisotropy: 8,
});
try {
computePassEncoder94.setBindGroup(3, bindGroup97);
} catch {}
try {
computePassEncoder107.setBindGroup(2, bindGroup0, new Uint32Array(3064), 95, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup60);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer148, 'uint16', 1_340, 1_565);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer136, 6_660, 1_024);
} catch {}
try {
buffer135.unmap();
} catch {}
try {
commandEncoder202.copyTextureToTexture({
  texture: texture68,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 22},
  aspect: 'all',
},
{
  texture: texture108,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
},
{width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let renderPassEncoder41 = commandEncoder200.beginRenderPass({
  label: '\u6873\u92e8\u07d6\u4188\u01f4\u{1ffe4}\uba08\uef54\u08d4\u{1f7d4}',
  colorAttachments: [{
  view: textureView94,
  clearValue: { r: 139.3, g: 980.7, b: -617.5, a: 177.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder40.setBindGroup(3, bindGroup28, new Uint32Array(865), 39, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer119, 1112, new BigUint64Array(4775), 96, 128);
} catch {}
let texture250 = device0.createTexture({
  size: [13],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView242 = texture30.createView({label: '\u0608\uc8b4\u36ba\u1f2b\u49ca', baseArrayLayer: 0});
let computePassEncoder167 = commandEncoder202.beginComputePass({label: '\ua422\u829e\u07fd\u{1f742}'});
try {
computePassEncoder149.setBindGroup(0, bindGroup10, new Uint32Array(8474), 469, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(2, bindGroup40);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup89, new Uint32Array(545), 71, 0);
} catch {}
let buffer165 = device0.createBuffer({
  size: 10062,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder68.setBindGroup(1, bindGroup76);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup91);
} catch {}
try {
renderPassEncoder38.setBindGroup(2, bindGroup12, new Uint32Array(19), 6, 0);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle4, renderBundle6]);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(1, buffer83, 0, 241);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer76.unmap();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let textureView243 = texture42.createView({label: '\u{1fef5}\uc980\uc3c5', dimension: '2d-array'});
try {
computePassEncoder158.setBindGroup(0, bindGroup94);
} catch {}
try {
computePassEncoder31.setBindGroup(1, bindGroup15, new Uint32Array(414), 145, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(6, buffer84, 4_964, 911);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder203 = device0.createCommandEncoder({});
let texture251 = device0.createTexture({
  size: [322, 2, 1],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView244 = texture98.createView({format: 'r16sint', mipLevelCount: 1, arrayLayerCount: 1});
let externalTexture27 = device0.importExternalTexture({source: videoFrame1});
try {
renderPassEncoder40.setBindGroup(1, bindGroup13, new Uint32Array(3025), 382, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer36, 'uint16', 9_382, 944);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'bt2020_10bit'} });
let bindGroup115 = device0.createBindGroup({layout: bindGroupLayout29, entries: [{binding: 166, resource: textureView75}]});
let commandEncoder204 = device0.createCommandEncoder({label: '\u70d0\u82b0\u090d\u03f5\u0b8d\uae21\u82a9\u9622\u1d6b\u573f\u825b'});
let querySet32 = device0.createQuerySet({type: 'occlusion', count: 1759});
let externalTexture28 = device0.importExternalTexture({source: videoFrame23});
try {
renderPassEncoder40.setVertexBuffer(2, buffer3);
} catch {}
try {
buffer118.unmap();
} catch {}
try {
commandEncoder203.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 980 */
  offset: 980,
  bytesPerRow: 22016,
  rowsPerImage: 1252,
  buffer: buffer89,
}, {
  texture: texture138,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup116 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [{binding: 197, resource: {buffer: buffer49, offset: 512}}, {binding: 46, resource: textureView163}],
});
let sampler117 = device0.createSampler({
  label: '\u{1f9b6}\u{1f9e6}\u32be\u0bb2\u6360\ubb19\udaca\ue304\uf339\u0ffc\ua9dd',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 31.29,
  lodMaxClamp: 54.75,
  maxAnisotropy: 1,
});
try {
renderPassEncoder1.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer80, 'uint32', 544, 1_147);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
commandEncoder203.copyBufferToBuffer(buffer149, 1104, buffer1, 1112, 6280);
} catch {}
try {
commandEncoder204.copyTextureToTexture({
  texture: texture221,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture216,
  mipLevel: 0,
  origin: {x: 4, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'iec6196624'} });
try {
querySet22.label = '\u040c\u{1f82b}\u0852\ud16e\u{1fb65}';
} catch {}
let bindGroup117 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [
    {binding: 197, resource: {buffer: buffer61, offset: 2048, size: 784}},
    {binding: 46, resource: textureView163},
  ],
});
let texture252 = device0.createTexture({
  size: [2, 2, 27],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder42 = commandEncoder204.beginRenderPass({
  colorAttachments: [{
  view: textureView45,
  clearValue: { r: 583.9, g: -72.97, b: 585.8, a: -339.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet25,
});
let sampler118 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 85.45,
  lodMaxClamp: 94.90,
  compare: 'always',
  maxAnisotropy: 19,
});
try {
renderPassEncoder17.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(4, buffer137);
} catch {}
try {
commandEncoder203.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1660 */
  offset: 1660,
  rowsPerImage: 479,
  buffer: buffer23,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder203.copyTextureToTexture({
  texture: texture250,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture206,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder203.resolveQuerySet(querySet31, 81, 49, buffer43, 0);
} catch {}
let bindGroup118 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [
    {binding: 46, resource: textureView163},
    {binding: 197, resource: {buffer: buffer152, offset: 3072, size: 2248}},
  ],
});
let buffer166 = device0.createBuffer({
  size: 10788,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true});
let renderBundle28 = renderBundleEncoder28.finish({label: '\u7aa7\u0b97'});
try {
computePassEncoder95.setBindGroup(0, bindGroup104, new Uint32Array(1587), 635, 0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle0, renderBundle6]);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer1, 'uint16', 24, 3_489);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline1);
} catch {}
try {
commandEncoder203.insertDebugMarker('\u05e4');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 645, height: 4, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 0, y: 14 },
  flipY: true,
}, {
  texture: texture66,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder205 = device0.createCommandEncoder();
let textureView245 = texture165.createView({baseArrayLayer: 4, arrayLayerCount: 75});
let texture253 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 102},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView246 = texture231.createView({arrayLayerCount: 1});
let renderPassEncoder43 = commandEncoder203.beginRenderPass({
  colorAttachments: [{
  view: textureView94,
  clearValue: { r: -700.6, g: 548.0, b: 70.72, a: -493.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder21.setBindGroup(1, bindGroup21);
} catch {}
try {
computePassEncoder146.setBindGroup(2, bindGroup9, new Uint32Array(542), 17, 0);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup30, []);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(89);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.setVertexBuffer(2, buffer6, 0, 9_114);
} catch {}
try {
gpuCanvasContext8.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, alphaMode: 'opaque'});
} catch {}
await gc();
let buffer167 = device0.createBuffer({size: 935, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let sampler119 = device0.createSampler({
  label: '\u{1fc81}\u0f24\u7382\u31ae\u0cb2\uadf2\u{1fcc8}\u2386\u0b81\ua5f8',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 25.12,
});
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder205.copyTextureToBuffer({
  texture: texture57,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 142 widthInBlocks: 71 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1816 */
  offset: 1816,
  bytesPerRow: 29440,
  buffer: buffer28,
}, {width: 71, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
let bindGroup119 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 31, resource: textureView234}]});
let externalTexture29 = device0.importExternalTexture({source: videoFrame18});
try {
renderPassEncoder41.setIndexBuffer(buffer39, 'uint32', 208, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer165);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470m', transfer: 'smpteSt4281'} });
let bindGroup120 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 208, resource: textureView65},
    {binding: 159, resource: textureView142},
    {binding: 31, resource: textureView201},
  ],
});
let texture254 = device0.createTexture({
  size: [1290, 8, 125],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder10.setBindGroup(3, bindGroup5, new Uint32Array(1325), 370, 0);
} catch {}
try {
renderPassEncoder22.beginOcclusionQuery(10);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer80, 988, new BigUint64Array(21043), 2190, 72);
} catch {}
let buffer168 = device0.createBuffer({
  label: '\u913d\ue855\u0b93\u5b20\u0bed\u{1ff3f}\uffb0\u91d6',
  size: 12149,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder206 = device0.createCommandEncoder({});
let querySet33 = device0.createQuerySet({type: 'occlusion', count: 291});
let textureView247 = texture56.createView({
  label: '\u{1f8aa}\u{1fe65}\u1f48\u0272\u6a5a\u0667\u0142\u01dc\u87bb\u0e21',
  baseArrayLayer: 35,
  arrayLayerCount: 1,
});
try {
renderPassEncoder13.setBindGroup(1, bindGroup51, new Uint32Array(428), 275, 0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder29.setBindGroup(0, bindGroup112, new Uint32Array(574), 27, 0);
} catch {}
try {
renderBundleEncoder29.insertDebugMarker('\u{1f7be}');
} catch {}
try {
  await promise19;
} catch {}
let commandEncoder207 = device0.createCommandEncoder();
let computePassEncoder168 = commandEncoder207.beginComputePass();
try {
querySet16.destroy();
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\u2c59');
} catch {}
let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: []});
let computePassEncoder169 = commandEncoder205.beginComputePass();
let renderPassEncoder44 = commandEncoder206.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  clearValue: { r: -809.6, g: 42.47, b: -14.74, a: 956.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet27,
});
let renderBundle29 = renderBundleEncoder29.finish({});
let sampler120 = device0.createSampler({
  label: '\ud77a\u7971\uf7fb\u{1fe33}\u9620\u0625\u7354',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 43.11,
  lodMaxClamp: 43.45,
  maxAnisotropy: 2,
});
try {
renderPassEncoder27.setPipeline(pipeline1);
} catch {}
let pipeline2 = await device0.createComputePipelineAsync({layout: pipelineLayout6, compute: {module: shaderModule1}});
let textureView248 = texture142.createView({});
try {
computePassEncoder72.setBindGroup(2, bindGroup7, new Uint32Array(25), 4, 0);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder42.setBindGroup(3, bindGroup104, new Uint32Array(4871), 186, 0);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(126);
} catch {}
let buffer169 = device0.createBuffer({
  size: 6127,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder208 = device0.createCommandEncoder({});
let texture255 = device0.createTexture({
  size: [1290, 8, 125],
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder58.setBindGroup(1, bindGroup55);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
commandEncoder208.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 9, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 358 */
  offset: 334,
  buffer: buffer146,
}, {width: 12, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
renderPassEncoder31.insertDebugMarker('\u{1fff6}');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData32 = new ImageData(232, 12);
let bindGroup121 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 348, resource: textureView9}, {binding: 90, resource: externalTexture27}],
});
let buffer170 = device0.createBuffer({size: 13111, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let computePassEncoder170 = commandEncoder208.beginComputePass({});
try {
computePassEncoder102.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup86);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let textureView249 = texture115.createView({label: '\u81da\u058c\u9466\ub857\ud0b5'});
let externalTexture30 = device0.importExternalTexture({source: videoFrame14});
try {
computePassEncoder14.setBindGroup(1, bindGroup104, []);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle18, renderBundle18]);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.insertDebugMarker('\ue490');
} catch {}
document.body.prepend(canvas2);
try {
adapter0.label = '\u0666\ucf2c\u0056\uc0e4\u0a2a';
} catch {}
let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder209 = device0.createCommandEncoder({});
let textureView250 = texture202.createView({dimension: '2d-array'});
let computePassEncoder171 = commandEncoder209.beginComputePass({});
try {
computePassEncoder94.setBindGroup(2, bindGroup117);
} catch {}
try {
computePassEncoder143.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder22.endOcclusionQuery();
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle0, renderBundle17, renderBundle2, renderBundle6, renderBundle1, renderBundle18, renderBundle2, renderBundle3]);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline1);
} catch {}
let promise20 = shaderModule4.getCompilationInfo();
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
texture3.label = '\u6040\u225d\u0391\u206e\ue69f\u55d7\u{1fc64}\u08a3';
} catch {}
let bindGroup122 = device0.createBindGroup({layout: bindGroupLayout29, entries: [{binding: 166, resource: textureView75}]});
let textureView251 = texture126.createView({dimension: '2d-array', format: 'r16float'});
try {
computePassEncoder163.setBindGroup(2, bindGroup88, new Uint32Array(884), 14, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(1, bindGroup35);
} catch {}
try {
renderPassEncoder35.setBindGroup(3, bindGroup55, new Uint32Array(2302), 409, 0);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(1, buffer169, 0, 1_871);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let bindGroup123 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler23}, {binding: 28, resource: textureView174}],
});
let commandEncoder210 = device0.createCommandEncoder({});
let computePassEncoder172 = commandEncoder210.beginComputePass({label: '\uf5c3\u9def\u01a8\u{1f6ea}\u1425\ub5b4\u81b0\u36de\u0e11\u{1f76a}\u0ad5'});
try {
computePassEncoder106.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(7, buffer72, 0);
} catch {}
try {
  await promise20;
} catch {}
let buffer171 = device0.createBuffer({size: 4040, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder211 = device0.createCommandEncoder();
let renderPassEncoder45 = commandEncoder211.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  clearValue: { r: 340.4, g: -222.2, b: -575.8, a: 175.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder42.setBindGroup(0, bindGroup16, new Uint32Array(959), 321, 0);
} catch {}
try {
computePassEncoder110.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup102, new Uint32Array(3813), 81, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer72, 'uint32', 9_220, 3_262);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(5, buffer140, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer95, 4524, new BigUint64Array(13695), 1269, 100);
} catch {}
let imageBitmap7 = await createImageBitmap(imageData27);
let querySet34 = device0.createQuerySet({type: 'occlusion', count: 1889});
let texture256 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder116.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer17, 'uint16', 2_028, 1_716);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let bindGroup124 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 593, resource: textureView218}]});
let buffer172 = device0.createBuffer({
  label: '\u{1f614}\u09f6\u8994',
  size: 25507,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView252 = texture54.createView({aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 1});
let sampler121 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 99.25,
});
try {
computePassEncoder151.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup9);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle7, renderBundle2, renderBundle1]);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer136, 'uint32', 5_452, 182);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
computePassEncoder85.setBindGroup(2, bindGroup86);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer159, 'uint16', 58, 3);
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
let bindGroup125 = device0.createBindGroup({layout: bindGroupLayout29, entries: [{binding: 166, resource: textureView75}]});
let commandEncoder212 = device0.createCommandEncoder();
let computePassEncoder173 = commandEncoder212.beginComputePass({});
let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], stencilReadOnly: true});
try {
computePassEncoder41.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup96, new Uint32Array(1937), 15, 0);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer84, 'uint32', 1_540, 13_762);
} catch {}
try {
renderBundleEncoder30.setBindGroup(3, bindGroup15, new Uint32Array(772), 270, 0);
} catch {}
try {
buffer82.unmap();
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
let commandEncoder213 = device0.createCommandEncoder({});
let textureView253 = texture43.createView({});
let renderPassEncoder46 = commandEncoder213.beginRenderPass({
  colorAttachments: [{view: textureView144, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 172222157,
});
try {
computePassEncoder148.setBindGroup(2, bindGroup35, []);
} catch {}
try {
computePassEncoder58.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer74, 'uint32', 856, 248);
} catch {}
let imageData33 = new ImageData(28, 4);
let commandEncoder214 = device0.createCommandEncoder({label: '\uac09\u2cba\udb60\u3ff6\ucf27\u{1fcaa}\u638b'});
let texture257 = device0.createTexture({
  size: [27, 4, 1],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder174 = commandEncoder214.beginComputePass({});
try {
computePassEncoder24.setBindGroup(0, bindGroup28);
} catch {}
try {
computePassEncoder155.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder23.beginOcclusionQuery(96);
} catch {}
try {
renderPassEncoder23.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(2, buffer167, 68, 750);
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); };
} catch {}
let bindGroup126 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 348, resource: textureView0}, {binding: 90, resource: externalTexture1}],
});
let commandEncoder215 = device0.createCommandEncoder({});
let texture258 = device0.createTexture({
  size: [161, 1, 3],
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView254 = texture167.createView({});
let renderBundleEncoder31 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  stencilReadOnly: false,
});
let renderBundle30 = renderBundleEncoder31.finish({});
try {
computePassEncoder98.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder30.setBindGroup(1, bindGroup79, []);
} catch {}
try {
renderBundleEncoder30.setBindGroup(2, bindGroup41, new Uint32Array(623), 104, 0);
} catch {}
try {
buffer20.unmap();
} catch {}
try {
commandEncoder215.copyBufferToTexture({
  /* bytesInLastRow: 240 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1736 */
  offset: 1736,
  rowsPerImage: 224,
  buffer: buffer76,
}, {
  texture: texture142,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer54, 2156, new Int16Array(4549), 1246, 1052);
} catch {}
let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'iec6196624'} });
let bindGroup127 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 107, resource: textureView191},
    {binding: 9, resource: {buffer: buffer164, offset: 3072, size: 343}},
    {binding: 115, resource: textureView201},
    {binding: 268, resource: textureView200},
    {binding: 38, resource: textureView136},
    {binding: 245, resource: textureView150},
    {binding: 296, resource: textureView232},
    {binding: 41, resource: {buffer: buffer20, offset: 3584, size: 2084}},
  ],
});
try {
renderPassEncoder34.setBindGroup(3, bindGroup125);
} catch {}
try {
renderPassEncoder44.executeBundles([renderBundle17, renderBundle0]);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer17, 'uint32', 1_040, 4_006);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer166, 2_456, 1_181);
} catch {}
try {
renderBundleEncoder30.setBindGroup(1, bindGroup125);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer81, 'uint32', 760, 1_557);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(6, buffer166, 396, 583);
} catch {}
let textureView255 = texture234.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder29.setBindGroup(2, bindGroup106, new Uint32Array(6220), 71, 0);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle0, renderBundle14, renderBundle7, renderBundle2, renderBundle7, renderBundle28, renderBundle5]);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(5, buffer41, 0);
} catch {}
try {
commandEncoder215.resolveQuerySet(querySet12, 83, 31, buffer15, 256);
} catch {}
try {
device0.queue.writeBuffer(buffer151, 516, new Int16Array(25897), 4003, 1408);
} catch {}
let commandEncoder216 = device0.createCommandEncoder({});
let textureView256 = texture90.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder165.setBindGroup(2, bindGroup59);
} catch {}
try {
computePassEncoder168.setBindGroup(2, bindGroup109, new Uint32Array(1361), 37, 0);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder86.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder43.setBindGroup(2, bindGroup15, new Uint32Array(431), 75, 0);
} catch {}
try {
renderBundleEncoder30.setBindGroup(0, bindGroup73, new Uint32Array(1888), 196, 0);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(0, buffer84, 5_228, 1_625);
} catch {}
try {
buffer162.unmap();
} catch {}
let bindGroup128 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 31, resource: textureView208},
    {binding: 208, resource: textureView212},
    {binding: 159, resource: textureView146},
  ],
});
let textureView257 = texture127.createView({label: '\u{1f7aa}\u65b9\u6ba5\u{1fe2c}\uaf83\ub6a1\ue660', baseArrayLayer: 0});
let computePassEncoder175 = commandEncoder216.beginComputePass({});
let renderPassEncoder47 = commandEncoder215.beginRenderPass({
  colorAttachments: [{
  view: textureView68,
  clearValue: { r: 647.3, g: -23.54, b: 509.0, a: 341.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet13,
});
let renderBundle31 = renderBundleEncoder30.finish({});
let sampler122 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 91.00,
  lodMaxClamp: 94.28,
  maxAnisotropy: 4,
});
try {
renderPassEncoder33.setBindGroup(2, bindGroup9);
} catch {}
try {
renderPassEncoder25.setBindGroup(3, bindGroup39, new Uint32Array(4782), 89, 0);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder7.insertDebugMarker('\uc1a1');
} catch {}
let bindGroup129 = device0.createBindGroup({
  label: '\u0119\u458d\u07b3',
  layout: bindGroupLayout4,
  entries: [
    {binding: 7, resource: textureView174},
    {binding: 124, resource: textureView20},
    {binding: 29, resource: textureView26},
    {binding: 136, resource: textureView36},
    {binding: 112, resource: sampler18},
  ],
});
let commandEncoder217 = device0.createCommandEncoder({});
let computePassEncoder176 = commandEncoder217.beginComputePass({});
let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4});
let renderBundle32 = renderBundleEncoder32.finish();
try {
computePassEncoder84.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(500);
} catch {}
try {
texture87.destroy();
} catch {}
let commandEncoder218 = device0.createCommandEncoder({});
let computePassEncoder177 = commandEncoder218.beginComputePass({});
try {
computePassEncoder114.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder42.setScissorRect(5, 1, 1, 8);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer77, 'uint16', 2_352, 60);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline1);
} catch {}
try {
buffer168.unmap();
} catch {}
let pipeline3 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout6,
  fragment: {module: shaderModule3, targets: [{format: 'rg8uint'}]},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 360,
        stepMode: 'instance',
        attributes: [{format: 'uint8x4', offset: 88, shaderLocation: 7}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
try {
  await promise21;
} catch {}
let videoFrame34 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'film', transfer: 'gamma28curve'} });
let bindGroup130 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler120}, {binding: 28, resource: textureView168}],
});
let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture259 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture260 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 10},
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder38.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup60);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(7, buffer122, 1_028, 41);
} catch {}
try {
buffer82.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture88,
  mipLevel: 0,
  origin: {x: 7, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(531).fill(121), /* required buffer size: 531 */
{offset: 531, bytesPerRow: 2112}, {width: 262, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let sampler123 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 42.80,
  lodMaxClamp: 83.57,
});
try {
computePassEncoder74.setBindGroup(0, bindGroup51);
} catch {}
try {
computePassEncoder156.setPipeline(pipeline2);
} catch {}
document.body.prepend(canvas1);
let buffer173 = device0.createBuffer({
  label: '\u088c\u477a\u8125\uf269\u0634\u4c23\uc295\u978b',
  size: 5511,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder219 = device0.createCommandEncoder({});
let textureView258 = texture67.createView({baseArrayLayer: 6, arrayLayerCount: 6});
let computePassEncoder178 = commandEncoder219.beginComputePass({});
let renderBundleEncoder33 = device0.createRenderBundleEncoder({
  label: '\uc2b5\u0eb0\ua1b1\u12ba',
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
});
try {
computePassEncoder87.setPipeline(pipeline2);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: imageData17,
  origin: { x: 14, y: 3 },
  flipY: false,
}, {
  texture: texture191,
  mipLevel: 1,
  origin: {x: 15, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let bindGroup131 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 136, resource: textureView24},
    {binding: 112, resource: sampler85},
    {binding: 124, resource: textureView20},
    {binding: 7, resource: textureView174},
    {binding: 29, resource: textureView41},
  ],
});
let renderBundle33 = renderBundleEncoder33.finish();
try {
computePassEncoder24.setBindGroup(0, bindGroup64);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer101, 'uint16', 140, 669);
} catch {}
let bindGroupLayout30 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 82,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let textureView259 = texture68.createView({dimension: '2d', baseArrayLayer: 28});
try {
computePassEncoder177.setBindGroup(0, bindGroup93);
} catch {}
try {
renderPassEncoder44.setBindGroup(0, bindGroup125);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup4, new Uint32Array(238), 18, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer154, 0, 7_403);
} catch {}
try {
buffer154.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 0, y: 41 },
  flipY: true,
}, {
  texture: texture238,
  mipLevel: 0,
  origin: {x: 103, y: 66, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 10, depthOrArrayLayers: 0});
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer174: vec2i;

@group(0) @binding(38) var st15: texture_storage_3d<rg32float, write>;

@group(0) @binding(41) var<storage, read> buffer175: array<array<f16, 1>, 2>;

@group(0) @binding(107) var tex48: texture_1d<u32>;

@group(0) @binding(115) var tex49: texture_1d<i32>;

@group(0) @binding(268) var tex50: texture_2d_array<u32>;

@group(0) @binding(296) var tex51: texture_2d<u32>;

struct T0 {
  f0: vec2f,
}

struct VertexOutput7 {
  @location(3) f22: vec4u,
  @location(12) @interpolate(perspective, center) f23: f16,
  @location(9) f24: vec2i,
  @location(13) f25: vec4u,
  @location(10) @interpolate(perspective, sample) f26: vec2f,
  @builtin(position) f27: vec4f,
  @location(8) f28: vec4h,
}

@id(17206) override override9: f32;

override override10: i32;

override override11: u32;

override override12 = true;

override override13: f16 = 639.2;

override override14: u32 = 35;

fn fn0() -> mat4x2f {
  var out: mat4x2f;
  let ptr91: ptr<storage, array<f16, 1>, read> = &(*&buffer175)[u32(unconst_u32(39))];
  out -= mat4x2f(f32(buffer175[1][0]), f32(buffer175[1][0]), f32(buffer175[1][0]), f32(buffer175[1][0]), f32(buffer175[1][0]), f32(buffer175[1][0]), f32(buffer175[1][0]), f32(buffer175[1][0]));
  var vf84: f16 = override13;
  vf84 *= f16(pack2x16unorm(vec2f(unconst_f32(-0.1485), unconst_f32(0.07221))));
  let vf85: vec2i = min(vec2i(unconst_i32(428), unconst_i32(3)), vec2i(unconst_i32(207), unconst_i32(18)));
  let ptr92: ptr<storage, f16, read> = &(*ptr91)[0];
  let vf86: bool = override12;
  let ptr93: ptr<storage, f16, read> = &(*&buffer175)[u32(unconst_u32(42))][0];
  let vf87: bool = override12;
  out = mat4x2f(vec2f(unpack4xI8(u32(unconst_u32(118))).wy), bitcast<vec2f>(unpack4xI8(u32(unconst_u32(118))).wz), bitcast<vec2f>(unpack4xI8(u32(unconst_u32(118))).yw), vec2f(unpack4xI8(u32(unconst_u32(118))).yy));
  vf84 += pow(vec3h(unconst_f16(12070.9), unconst_f16(3799.5), unconst_f16(11757.6)), vec3h(unconst_f16(10450.0), unconst_f16(-20522.1), unconst_f16(1373.5))).z;
  out -= mat4x2f(ceil(vec4f(unconst_f32(0.2482), unconst_f32(0.1628), unconst_f32(0.07435), unconst_f32(0.03380))).rg, ceil(vec4f(unconst_f32(0.2482), unconst_f32(0.1628), unconst_f32(0.07435), unconst_f32(0.03380))).zw, ceil(vec4f(unconst_f32(0.2482), unconst_f32(0.1628), unconst_f32(0.07435), unconst_f32(0.03380))).yz, ceil(vec4f(unconst_f32(0.2482), unconst_f32(0.1628), unconst_f32(0.07435), unconst_f32(0.03380))).xw);
  let vf88: vec4f = unpack4x8unorm(u32(unconst_u32(371)));
  let vf89: vec4f = unpack4x8unorm(u32(unconst_u32(167)));
  let ptr94: ptr<storage, f16, read> = &buffer175[1][u32(unconst_u32(25))];
  return out;
  _ = override13;
  _ = override12;
}

var<workgroup> vw25: atomic<u32>;

var<workgroup> vw26: array<atomic<u32>, 58>;

@vertex
fn vertex8(@location(13) @interpolate(flat, center) a0: u32, @location(8) @interpolate(flat) a1: vec4i, @location(2) @interpolate(perspective, center) a2: vec2f) -> VertexOutput7 {
  var out: VertexOutput7;
  fn0();
  fn0();
  out.f25 >>= unpack4xU8(u32(buffer175[u32(unconst_u32(333))][0]));
  let ptr95: ptr<storage, array<array<f16, 1>, 2>, read> = &buffer175;
  let vf90: u32 = dot4U8Packed(u32(unconst_u32(272)), u32(override13));
  return out;
  _ = override13;
  _ = override12;
}

@compute @workgroup_size(2, 1, 1)
fn compute5() {
  var vf91: u32 = textureNumLayers(tex50);
  let ptr96: ptr<workgroup, atomic<u32>> = &vw26[57];
  let ptr97: ptr<workgroup, atomic<u32>> = &vw26[u32(unconst_u32(25))];
  textureStore(st15, vec3i(unconst_i32(-233), unconst_i32(402), unconst_i32(73)), vec4f(vec4f(unconst_f32(0.00818), unconst_f32(0.03445), unconst_f32(0.09282), unconst_f32(0.4157))));
  let ptr98: ptr<storage, f16, read> = &buffer175[1][0];
  atomicXor(&vw25, u32(unconst_u32(99)));
  storageBarrier();
  let vf92: u32 = atomicLoad(&(*&vw26)[57]);
  var vf93: u32 = atomicLoad(&vw26[57]);
  textureStore(st15, vec3i(unconst_i32(2), unconst_i32(201), unconst_i32(36)), vec4f(vec4f(unconst_f32(0.1220), unconst_f32(0.1771), unconst_f32(0.07687), unconst_f32(0.1755))));
  let ptr99: ptr<workgroup, atomic<u32>> = &(*&vw26)[57];
  vf93 += atomicLoad(&(*&vw26)[u32(unconst_u32(43))]);
  atomicCompareExchangeWeak(&vw26[u32(unconst_u32(389))], unconst_u32(24), unconst_u32(393));
  let vf94: u32 = atomicExchange(&vw26[57], u32(unconst_u32(212)));
  var vf95: u32 = atomicExchange(&(*&vw25), u32(unconst_u32(51)));
  vf91 += u32(buffer175[u32(unconst_u32(121))][0]);
  let ptr100: ptr<storage, f16, read> = &(*ptr98);
  let ptr101: ptr<storage, f16, read> = &buffer175[1][0];
  let ptr102: ptr<workgroup, atomic<u32>> = &vw25;
}`,
});
let textureView260 = texture170.createView({dimension: '2d-array'});
let textureView261 = texture143.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let sampler124 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 52.08,
  lodMaxClamp: 91.06,
  maxAnisotropy: 3,
});
try {
computePassEncoder165.setBindGroup(2, bindGroup122, []);
} catch {}
try {
computePassEncoder166.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer169, 'uint16', 38, 249);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder220 = device0.createCommandEncoder();
let sampler125 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 62.43,
  lodMaxClamp: 93.95,
  maxAnisotropy: 19,
});
try {
computePassEncoder103.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer75, 'uint16', 3_432, 4_474);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 20, y: 5 },
  flipY: true,
}, {
  texture: texture191,
  mipLevel: 0,
  origin: {x: 18, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas2);
let computePassEncoder179 = commandEncoder220.beginComputePass({});
let sampler126 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 97.58,
});
try {
computePassEncoder124.setBindGroup(3, bindGroup117);
} catch {}
try {
computePassEncoder129.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder91.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder42.beginOcclusionQuery(29);
} catch {}
try {
renderPassEncoder42.endOcclusionQuery();
} catch {}
let arrayBuffer15 = buffer90.getMappedRange(8424, 0);
let commandEncoder221 = device0.createCommandEncoder({});
let computePassEncoder180 = commandEncoder221.beginComputePass({});
try {
renderPassEncoder46.setBindGroup(0, bindGroup56);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer77, 'uint16', 618, 41);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(0, buffer97, 332, 187);
} catch {}
try {
buffer100.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer176 = device0.createBuffer({
  size: 26067,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder222 = device0.createCommandEncoder();
let textureView262 = texture17.createView({});
let computePassEncoder181 = commandEncoder222.beginComputePass({});
try {
computePassEncoder75.setBindGroup(0, bindGroup47);
} catch {}
try {
computePassEncoder148.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder47.setBindGroup(2, bindGroup24);
} catch {}
try {
buffer35.unmap();
} catch {}
document.body.append(img0);
let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'bt2020_10bit'} });
let bindGroup132 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 293, resource: textureView110}]});
let commandEncoder223 = device0.createCommandEncoder({});
let texture261 = device0.createTexture({size: [26], dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_DST});
let textureView263 = texture40.createView({format: 'rg8uint'});
try {
renderPassEncoder8.setIndexBuffer(buffer8, 'uint16', 1_870, 574);
} catch {}
let commandEncoder224 = device0.createCommandEncoder();
let textureView264 = texture131.createView({});
let renderPassEncoder48 = commandEncoder223.beginRenderPass({
  colorAttachments: [{
  view: textureView68,
  clearValue: { r: -100.8, g: -217.3, b: -162.2, a: 817.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder130.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder3.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder42.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup88, new Uint32Array(1043), 454, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer72, 'uint32', 2_332, 333);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(1, buffer15, 0, 180);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let bindGroup133 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler109}, {binding: 28, resource: textureView228}],
});
let buffer177 = device0.createBuffer({
  label: '\u8cb6\ucdb5\u0b6c\u0342\ub58a\u09b9',
  size: 3978,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView265 = texture22.createView({});
let computePassEncoder182 = commandEncoder224.beginComputePass({});
try {
computePassEncoder136.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(7, buffer24, 0, 1_632);
} catch {}
try {
  await promise22;
} catch {}
let videoFrame36 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'pq'} });
try {
renderPassEncoder18.setBindGroup(3, bindGroup81);
} catch {}
try {
renderPassEncoder45.executeBundles([renderBundle14, renderBundle0]);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroupLayout31 = device0.createBindGroupLayout({
  entries: [
    {binding: 44, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let commandEncoder225 = device0.createCommandEncoder();
let computePassEncoder183 = commandEncoder225.beginComputePass({});
try {
computePassEncoder36.setPipeline(pipeline2);
} catch {}
let arrayBuffer16 = buffer71.getMappedRange(0, 16);
try {
computePassEncoder181.insertDebugMarker('\u{1ffdc}');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture166,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(205).fill(248), /* required buffer size: 205 */
{offset: 205, bytesPerRow: 58, rowsPerImage: 208}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame37 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'unspecified'} });
let textureView266 = texture210.createView({dimension: 'cube', baseMipLevel: 0});
let texture262 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 196},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm'],
});
try {
computePassEncoder138.setBindGroup(3, bindGroup133);
} catch {}
try {
computePassEncoder78.setPipeline(pipeline2);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder226 = device0.createCommandEncoder({});
let renderPassEncoder49 = commandEncoder226.beginRenderPass({
  colorAttachments: [{
  view: textureView243,
  clearValue: { r: -544.7, g: 746.4, b: -61.06, a: -539.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet28,
});
let renderBundleEncoder34 = device0.createRenderBundleEncoder({
  label: '\u0d83\u6253\u743a\u89f5\u0ddb\u5708\u{1f950}\u0f7b\uf1cd',
  colorFormats: ['rg8uint'],
  depthReadOnly: true,
});
let sampler127 = device0.createSampler({
  label: '\u082a\u{1ff4a}\u5a98\u044b\u{1f6a0}',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 25.16,
  lodMaxClamp: 37.46,
  maxAnisotropy: 1,
});
try {
computePassEncoder81.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer87, 'uint16', 164, 761);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(1, undefined);
} catch {}
try {
renderBundleEncoder34.setIndexBuffer(buffer169, 'uint32', 1_476, 672);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline1);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
sampler29.label = '\u2be9\u0efd';
} catch {}
let bindGroup134 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 159, resource: textureView254},
    {binding: 31, resource: textureView201},
    {binding: 208, resource: textureView197},
  ],
});
let texture263 = device0.createTexture({
  size: [13, 10, 16],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView267 = texture51.createView({arrayLayerCount: 4});
try {
computePassEncoder52.setBindGroup(1, bindGroup13);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture264 = device0.createTexture({size: [52, 40, 64], dimension: '3d', format: 'r8uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder58.setBindGroup(1, bindGroup93, new Uint32Array(1884), 606, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer100, 2_232, 6_856);
} catch {}
try {
renderBundleEncoder34.setBindGroup(2, bindGroup112);
} catch {}
try {
computePassEncoder11.pushDebugGroup('\u2548');
} catch {}
let canvas6 = document.createElement('canvas');
try {
computePassEncoder110.setBindGroup(3, bindGroup112);
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle14]);
} catch {}
try {
renderBundleEncoder34.setBindGroup(2, bindGroup35, new Uint32Array(456), 63, 0);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 102}
*/
{
  source: canvas1,
  origin: { x: 48, y: 27 },
  flipY: true,
}, {
  texture: texture253,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 9},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 168, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture265 = device0.createTexture({
  label: '\u{1fc76}\u14c9',
  size: {width: 104, height: 80, depthOrArrayLayers: 128},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler128 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.92,
  maxAnisotropy: 16,
});
try {
renderPassEncoder4.setIndexBuffer(buffer43, 'uint16', 82, 89);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder41.setVertexBuffer(5, buffer171, 0);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(5, buffer176, 2_968, 2_378);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let imageBitmap8 = await createImageBitmap(imageData21);
let buffer178 = device0.createBuffer({size: 5409, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let textureView268 = texture176.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 9});
try {
renderPassEncoder31.executeBundles([renderBundle29, renderBundle27, renderBundle27, renderBundle29]);
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup78);
} catch {}
await gc();
let sampler129 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 60.40,
  maxAnisotropy: 2,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup64, new Uint32Array(2138), 208, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup115);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer61, 'uint16', 3_628, 2_633);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 204, new Int16Array(12711), 284, 12);
} catch {}
let texture266 = device0.createTexture({
  size: {width: 55, height: 8, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder180.setBindGroup(3, bindGroup91);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup48);
} catch {}
try {
renderPassEncoder41.executeBundles([renderBundle31]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer117, 'uint32', 96, 1_546);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(5, buffer159);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1290, height: 8, depthOrArrayLayers: 10}
*/
{
  source: imageData15,
  origin: { x: 5, y: 7 },
  flipY: false,
}, {
  texture: texture215,
  mipLevel: 0,
  origin: {x: 710, y: 1, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 4, depthOrArrayLayers: 0});
} catch {}
let videoFrame38 = new VideoFrame(videoFrame11, {timestamp: 0});
let bindGroup135 = device0.createBindGroup({
  label: '\u0a39\u01c1\u{1f6ef}\u{1fd21}\u{1f738}\u0fd4\ufb13\uf1f0\u5f2a\u{1f969}\ud351',
  layout: bindGroupLayout18,
  entries: [{binding: 43, resource: textureView179}],
});
let commandEncoder227 = device0.createCommandEncoder();
let textureView269 = texture131.createView({label: '\u660f\u95f4\uc0b7\ucce6\u7ba4\ua49c\u0790\uedb5', baseArrayLayer: 0});
let computePassEncoder184 = commandEncoder227.beginComputePass({});
try {
computePassEncoder179.setBindGroup(1, bindGroup114, new Uint32Array(2742), 13, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup9, []);
} catch {}
try {
renderBundleEncoder34.setBindGroup(0, bindGroup32);
} catch {}
try {
renderBundleEncoder34.setBindGroup(2, bindGroup121, new Uint32Array(214), 195, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame34,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture238,
  mipLevel: 0,
  origin: {x: 97, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder228 = device0.createCommandEncoder();
let textureView270 = texture210.createView({dimension: 'cube', baseMipLevel: 0, baseArrayLayer: 7});
let textureView271 = texture138.createView({arrayLayerCount: 1});
let computePassEncoder185 = commandEncoder228.beginComputePass({});
let renderBundle34 = renderBundleEncoder34.finish();
try {
computePassEncoder152.setBindGroup(1, bindGroup40);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 396, new Int16Array(22920), 2988, 216);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle31]);
} catch {}
let promise23 = shaderModule5.getCompilationInfo();
let buffer179 = device0.createBuffer({
  size: 15144,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder229 = device0.createCommandEncoder({});
let texture267 = device0.createTexture({
  size: [52, 40, 56],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler130 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 69.05,
  lodMaxClamp: 70.62,
  compare: 'less-equal',
});
try {
computePassEncoder3.end();
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer61, 'uint32', 3_292, 1_556);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(6, buffer99, 0, 31);
} catch {}
try {
  await promise23;
} catch {}
document.body.prepend(canvas4);
let videoFrame39 = new VideoFrame(videoFrame28, {timestamp: 0});
let commandEncoder230 = device0.createCommandEncoder({});
let texture268 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder136.setBindGroup(1, bindGroup42);
} catch {}
try {
commandEncoder229.copyBufferToBuffer(buffer87, 504, buffer80, 596, 452);
} catch {}
try {
commandEncoder229.copyBufferToTexture({
  /* bytesInLastRow: 296 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 184 */
  offset: 184,
  bytesPerRow: 24064,
  buffer: buffer44,
}, {
  texture: texture206,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {width: 37, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder0.copyTextureToBuffer({
  texture: texture195,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1760 */
  offset: 1760,
  bytesPerRow: 13312,
  buffer: buffer171,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
try {
adapter0.label = '\u{1fbec}\uba42\ubd03\u3e70\u0087\u{1fa3d}\u0936';
} catch {}
let bindGroup136 = device0.createBindGroup({
  label: '\u05d1\u4a1f\u059d\u{1f78d}\u044d\u4923\u{1ff84}\udb2c',
  layout: bindGroupLayout10,
  entries: [
    {binding: 62, resource: sampler7},
    {binding: 99, resource: {buffer: buffer56, offset: 0, size: 1627}},
    {binding: 61, resource: textureView0},
    {binding: 697, resource: {buffer: buffer62, offset: 9472}},
    {binding: 195, resource: textureView10},
    {binding: 33, resource: textureView143},
    {binding: 161, resource: textureView76},
    {binding: 117, resource: {buffer: buffer19, offset: 1024, size: 1109}},
    {binding: 142, resource: textureView159},
    {binding: 67, resource: textureView109},
    {binding: 34, resource: sampler41},
    {binding: 330, resource: {buffer: buffer29, offset: 7168}},
    {binding: 712, resource: {buffer: buffer48, offset: 0, size: 460}},
    {binding: 5, resource: textureView38},
    {binding: 141, resource: textureView90},
    {binding: 54, resource: externalTexture16},
    {binding: 216, resource: {buffer: buffer16, offset: 1536, size: 4143}},
    {binding: 232, resource: {buffer: buffer61, offset: 2560, size: 8764}},
    {binding: 95, resource: sampler68},
    {binding: 209, resource: textureView212},
    {binding: 38, resource: sampler83},
    {binding: 112, resource: textureView211},
    {binding: 36, resource: sampler52},
    {binding: 15, resource: textureView197},
    {binding: 49, resource: {buffer: buffer81, offset: 1024}},
    {binding: 55, resource: {buffer: buffer37, offset: 1536}},
    {binding: 47, resource: sampler74},
    {binding: 318, resource: {buffer: buffer44, offset: 256, size: 4284}},
    {binding: 20, resource: externalTexture27},
    {binding: 29, resource: sampler130},
    {binding: 118, resource: textureView100},
    {binding: 8, resource: textureView266},
    {binding: 328, resource: textureView174},
    {binding: 125, resource: textureView110},
    {binding: 348, resource: textureView232},
    {binding: 135, resource: externalTexture8},
    {binding: 384, resource: externalTexture30},
    {binding: 68, resource: {buffer: buffer17, offset: 1024, size: 1464}},
    {binding: 479, resource: externalTexture5},
    {binding: 65, resource: textureView100},
    {binding: 228, resource: {buffer: buffer44, offset: 3584, size: 8876}},
    {binding: 162, resource: textureView134},
    {binding: 2, resource: textureView76},
    {binding: 408, resource: textureView25},
  ],
});
let textureView272 = texture166.createView({dimension: '2d-array', aspect: 'all'});
let computePassEncoder186 = commandEncoder0.beginComputePass({});
let externalTexture31 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'});
try {
computePassEncoder40.setBindGroup(1, bindGroup130, new Uint32Array(21), 2, 0);
} catch {}
try {
computePassEncoder35.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder99.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup0, new Uint32Array(5510), 229, 0);
} catch {}
try {
renderPassEncoder45.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture161,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 11},
  aspect: 'all',
}, new Uint8Array(26).fill(155), /* required buffer size: 26 */
{offset: 26, rowsPerImage: 25}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let commandEncoder231 = device0.createCommandEncoder();
try {
computePassEncoder17.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder76.setBindGroup(0, bindGroup124, new Uint32Array(448), 368, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer148, 'uint16', 1_416, 2_803);
} catch {}
try {
renderPassEncoder49.setPipeline(pipeline1);
} catch {}
try {
commandEncoder230.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 232 */
  offset: 232,
  buffer: buffer171,
}, {
  texture: texture182,
  mipLevel: 0,
  origin: {x: 56, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder232 = device0.createCommandEncoder();
let renderBundleEncoder35 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
});
try {
renderPassEncoder38.setBindGroup(3, bindGroup12, new Uint32Array(3033), 110, 0);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder35.setBindGroup(0, bindGroup50, new Uint32Array(58), 7, 0);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline0);
} catch {}
try {
commandEncoder229.copyBufferToTexture({
  /* bytesInLastRow: 2640 widthInBlocks: 165 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2192 */
  offset: 2192,
  bytesPerRow: 9472,
  buffer: buffer177,
}, {
  texture: texture170,
  mipLevel: 0,
  origin: {x: 216, y: 0, z: 0},
  aspect: 'all',
}, {width: 165, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder13.insertDebugMarker('\uf90d');
} catch {}
let texture269 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 64},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView273 = texture150.createView({label: '\u{1f9ad}\u87d3\u62ec\ue5cf\u{1f6f2}', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 4});
try {
renderPassEncoder17.setBlendConstant({ r: 780.2, g: 958.5, b: 216.9, a: 720.0, });
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline1);
} catch {}
let arrayBuffer17 = buffer0.getMappedRange(104, 0);
try {
commandEncoder231.copyBufferToBuffer(buffer163, 432, buffer6, 18824, 128);
} catch {}
try {
commandEncoder232.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 606 */
  offset: 606,
  bytesPerRow: 35328,
  buffer: buffer65,
}, {
  texture: texture203,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder230.clearBuffer(buffer73, 668, 452);
} catch {}
try {
computePassEncoder11.popDebugGroup();
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let textureView274 = texture137.createView({aspect: 'all'});
let computePassEncoder187 = commandEncoder230.beginComputePass({});
try {
computePassEncoder147.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder39.setBindGroup(1, bindGroup100);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup8, new Uint32Array(609), 78, 0);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(1, buffer136);
} catch {}
try {
renderBundleEncoder35.setBindGroup(2, bindGroup97, new Uint32Array(227), 0, 0);
} catch {}
try {
renderBundleEncoder35.setIndexBuffer(buffer170, 'uint16', 74, 1_955);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(2, buffer152, 0);
} catch {}
try {
buffer88.unmap();
} catch {}
let bindGroup137 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 28, resource: textureView145}, {binding: 162, resource: sampler50}],
});
let buffer180 = device0.createBuffer({
  size: 12637,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder17.executeBundles([renderBundle14, renderBundle5, renderBundle1]);
} catch {}
try {
renderBundleEncoder35.setBindGroup(1, bindGroup47);
} catch {}
try {
commandEncoder231.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 8088 */
  offset: 8088,
  buffer: buffer176,
}, {
  texture: texture86,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let commandEncoder233 = device0.createCommandEncoder({});
try {
computePassEncoder123.setBindGroup(3, bindGroup15, new Uint32Array(940), 210, 0);
} catch {}
try {
computePassEncoder141.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder124.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup17);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline0);
} catch {}
let commandEncoder234 = device0.createCommandEncoder({});
let computePassEncoder188 = commandEncoder232.beginComputePass({});
let sampler131 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 39.12,
  lodMaxClamp: 78.01,
});
try {
computePassEncoder108.setBindGroup(3, bindGroup20);
} catch {}
try {
computePassEncoder30.setBindGroup(2, bindGroup27, new Uint32Array(1218), 250, 0);
} catch {}
try {
computePassEncoder49.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup79, new Uint32Array(188), 1, 0);
} catch {}
try {
renderBundleEncoder35.setBindGroup(3, bindGroup99, new Uint32Array(991), 411, 0);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(6, buffer54, 1_028, 3_681);
} catch {}
try {
computePassEncoder26.pushDebugGroup('\u9b4b');
} catch {}
let texture270 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC,
});
let computePassEncoder189 = commandEncoder231.beginComputePass({});
try {
computePassEncoder74.setBindGroup(3, bindGroup22, new Uint32Array(116), 3, 0);
} catch {}
try {
computePassEncoder145.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(2, buffer64, 28, 52);
} catch {}
try {
commandEncoder234.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3400 */
  offset: 3400,
  buffer: buffer88,
}, {
  texture: texture76,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer158, 632, new BigUint64Array(15962), 4610, 196);
} catch {}
let gpuCanvasContext9 = canvas6.getContext('webgpu');
let bindGroupLayout32 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 338,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 17,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder235 = device0.createCommandEncoder({label: '\u068a\u{1f818}\u{1f6f4}\u{1f8a7}\u473d\ud2d9\u02b6\u0a6c'});
let computePassEncoder190 = commandEncoder235.beginComputePass({label: '\u05ab\u00fe\u3c4d\u0ed2\u4eb7\u{1f6cf}\u{1fe4e}\u09ff'});
let sampler132 = device0.createSampler({
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 63.86,
  lodMaxClamp: 90.14,
  compare: 'greater',
  maxAnisotropy: 2,
});
try {
renderPassEncoder41.setViewport(13.783386697851185, 32.334389730653335, 35.86294698811745, 3.986822097963079, 0.8876483357309292, 0.9587385448547703);
} catch {}
try {
renderBundleEncoder35.setBindGroup(0, bindGroup0, new Uint32Array(693), 71, 0);
} catch {}
try {
renderBundleEncoder35.setIndexBuffer(buffer24, 'uint16', 2_244, 2_984);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(7, buffer176, 1_656);
} catch {}
try {
renderPassEncoder37.insertDebugMarker('\u{1fab2}');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture142,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(560).fill(83), /* required buffer size: 560 */
{offset: 560}, {width: 37, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder236 = device0.createCommandEncoder({});
let computePassEncoder191 = commandEncoder233.beginComputePass();
let sampler133 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 27.06,
});
try {
computePassEncoder97.setBindGroup(2, bindGroup51);
} catch {}
try {
renderPassEncoder37.setBindGroup(1, bindGroup47, new Uint32Array(278), 5, 0);
} catch {}
try {
renderPassEncoder14.setStencilReference(817);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer173, 'uint32', 56, 977);
} catch {}
try {
commandEncoder236.copyBufferToBuffer(buffer66, 3176, buffer28, 1328, 20);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView275 = texture59.createView({dimension: '2d-array', baseArrayLayer: 0});
let sampler134 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 82.29,
  lodMaxClamp: 93.95,
});
try {
computePassEncoder125.setBindGroup(3, bindGroup125, new Uint32Array(2685), 271, 0);
} catch {}
try {
renderPassEncoder32.setBindGroup(1, bindGroup129, new Uint32Array(3478), 386, 0);
} catch {}
try {
renderBundleEncoder35.setIndexBuffer(buffer79, 'uint32', 2_140, 2_023);
} catch {}
try {
device0.queue.writeBuffer(buffer97, 572, new Int16Array(3336), 223, 216);
} catch {}
document.body.append(img0);
let bindGroup138 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 208, resource: textureView109},
    {binding: 31, resource: textureView201},
    {binding: 159, resource: textureView146},
  ],
});
let commandEncoder237 = device0.createCommandEncoder();
let renderBundle35 = renderBundleEncoder35.finish({});
let sampler135 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 38.48,
  lodMaxClamp: 56.26,
  maxAnisotropy: 1,
});
try {
renderPassEncoder38.setBindGroup(0, bindGroup41, new Uint32Array(2405), 133, 0);
} catch {}
try {
renderPassEncoder30.beginOcclusionQuery(113);
} catch {}
try {
renderPassEncoder2.setViewport(40.89222836800229, 14.51169935345174, 5.175426696430399, 13.099949366139045, 0.8171316322638277, 0.8420652838939519);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline3);
} catch {}
let bindGroupLayout33 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 174,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 121,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 137,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder166.setBindGroup(0, bindGroup79);
} catch {}
try {
computePassEncoder42.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer28, 0, 212);
} catch {}
try {
renderBundleEncoder36.setBindGroup(3, bindGroup110, []);
} catch {}
try {
renderBundleEncoder36.setBindGroup(3, bindGroup99, new Uint32Array(21), 4, 0);
} catch {}
let promise24 = shaderModule3.getCompilationInfo();
try {
commandEncoder236.copyBufferToTexture({
  /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1238 */
  offset: 1238,
  buffer: buffer171,
}, {
  texture: texture119,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture22.label = '\u0736\uc616';
} catch {}
let computePassEncoder192 = commandEncoder237.beginComputePass({});
try {
renderPassEncoder46.setBindGroup(0, bindGroup95, new Uint32Array(554), 5, 0);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer119, 'uint32', 4_160, 616);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let texture271 = gpuCanvasContext1.getCurrentTexture();
let renderBundle36 = renderBundleEncoder36.finish({});
try {
renderPassEncoder39.setBindGroup(3, bindGroup50);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(1, buffer176, 0);
} catch {}
try {
commandEncoder229.copyBufferToTexture({
  /* bytesInLastRow: 5888 widthInBlocks: 368 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 784 */
  offset: 784,
  bytesPerRow: 42496,
  buffer: buffer12,
}, {
  texture: texture83,
  mipLevel: 0,
  origin: {x: 430, y: 0, z: 0},
  aspect: 'all',
}, {width: 368, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let imageBitmap9 = await createImageBitmap(videoFrame1);
let buffer181 = device0.createBuffer({size: 9073, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView276 = texture208.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 7});
let computePassEncoder193 = commandEncoder234.beginComputePass({});
try {
computePassEncoder173.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder25.setBindGroup(2, bindGroup123);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle18]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer118, 'uint32', 8, 170);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture159,
  mipLevel: 0,
  origin: {x: 8, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(741).fill(46), /* required buffer size: 741 */
{offset: 85, bytesPerRow: 13, rowsPerImage: 4}, {width: 3, height: 3, depthOrArrayLayers: 13});
} catch {}
let bindGroup139 = device0.createBindGroup({layout: bindGroupLayout15, entries: [{binding: 61, resource: textureView10}]});
let buffer182 = device0.createBuffer({size: 4573, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder238 = device0.createCommandEncoder({});
let textureView277 = texture253.createView({label: '\u422e\u0678', dimension: '2d', baseArrayLayer: 3});
let computePassEncoder194 = commandEncoder236.beginComputePass({});
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
document.body.append(canvas5);
let commandEncoder239 = device0.createCommandEncoder({});
let texture272 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder91.setBindGroup(0, bindGroup107);
} catch {}
try {
computePassEncoder38.setBindGroup(2, bindGroup94, new Uint32Array(852), 110, 0);
} catch {}
try {
renderPassEncoder37.setBindGroup(0, bindGroup63);
} catch {}
try {
renderPassEncoder12.setScissorRect(4, 2, 1, 4);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer122, 'uint32', 124, 395);
} catch {}
try {
adapter0.label = '\u0ea2\u0a6a\u081d\udc14';
} catch {}
let querySet35 = device0.createQuerySet({type: 'occlusion', count: 164});
let textureView278 = texture197.createView({arrayLayerCount: 1});
try {
computePassEncoder155.setBindGroup(0, bindGroup138);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder240 = device0.createCommandEncoder();
let texture273 = device0.createTexture({
  label: '\u8ab6\u8206\u{1fd15}',
  size: [13, 2, 1],
  sampleCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView279 = texture25.createView({});
let sampler136 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 0.04287,
  lodMaxClamp: 38.11,
  maxAnisotropy: 9,
});
try {
renderPassEncoder39.setBindGroup(0, bindGroup93);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(5, buffer156);
} catch {}
try {
commandEncoder239.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1572 */
  offset: 1572,
  buffer: buffer149,
}, {
  texture: texture244,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder240.copyTextureToTexture({
  texture: texture257,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture45,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 3388, new BigUint64Array(10651), 3298, 16);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1290, height: 8, depthOrArrayLayers: 10}
*/
{
  source: imageData4,
  origin: { x: 0, y: 6 },
  flipY: false,
}, {
  texture: texture215,
  mipLevel: 0,
  origin: {x: 231, y: 0, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup140 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 306, resource: textureView75},
    {binding: 8, resource: textureView201},
    {binding: 14, resource: {buffer: buffer36, offset: 512, size: 356}},
    {binding: 351, resource: {buffer: buffer97, offset: 256, size: 593}},
    {binding: 68, resource: {buffer: buffer100, offset: 256, size: 1214}},
    {binding: 160, resource: textureView242},
    {binding: 12, resource: {buffer: buffer77, offset: 0, size: 4588}},
    {binding: 44, resource: sampler80},
    {binding: 143, resource: {buffer: buffer7, offset: 0, size: 273}},
    {binding: 195, resource: textureView162},
    {binding: 88, resource: textureView54},
    {binding: 47, resource: textureView137},
    {binding: 185, resource: textureView100},
    {binding: 287, resource: textureView139},
    {binding: 0, resource: {buffer: buffer97, offset: 768, size: 2604}},
    {binding: 349, resource: sampler27},
    {binding: 163, resource: sampler82},
    {binding: 190, resource: textureView142},
    {binding: 70, resource: textureView197},
    {binding: 79, resource: {buffer: buffer33, offset: 1792, size: 320}},
    {binding: 196, resource: textureView151},
    {binding: 255, resource: {buffer: buffer81, offset: 512}},
    {binding: 6, resource: textureView141},
    {binding: 523, resource: textureView163},
    {binding: 252, resource: {buffer: buffer172, offset: 8192, size: 1456}},
    {binding: 177, resource: textureView100},
    {binding: 110, resource: textureView86},
    {binding: 389, resource: textureView198},
  ],
});
let buffer183 = device0.createBuffer({
  label: '\u{1f9ff}\u0fe5\u0543\u{1fbe0}\u00b7\u{1fedf}\uc43b\u0e59\u2014',
  size: 6992,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
});
let texture274 = device0.createTexture({
  size: [104, 80, 1],
  mipLevelCount: 1,
  format: 'etc2-rgb8a1unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder2.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder125.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.setScissorRect(8, 18, 1, 0);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer33, 'uint32', 1_472, 784);
} catch {}
try {
renderPassEncoder49.setPipeline(pipeline1);
} catch {}
try {
commandEncoder238.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 67},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'depth-only',
},
{width: 52, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup141 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 28, resource: textureView65}, {binding: 162, resource: sampler101}],
});
let computePassEncoder195 = commandEncoder238.beginComputePass();
let sampler137 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 31.04,
  lodMaxClamp: 86.03,
  compare: 'less-equal',
  maxAnisotropy: 20,
});
try {
computePassEncoder44.setBindGroup(1, bindGroup0, new Uint32Array(6587), 2_621, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder140.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup91, new Uint32Array(3214), 114, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline1);
} catch {}
try {
commandEncoder229.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3010 */
  offset: 3010,
  bytesPerRow: 25600,
  rowsPerImage: 39,
  buffer: buffer88,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder26.popDebugGroup();
} catch {}
let textureView280 = texture58.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 7});
let computePassEncoder196 = commandEncoder239.beginComputePass({});
let sampler138 = device0.createSampler({
  label: '\u0aa5\ud159',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 90.44,
  lodMaxClamp: 98.53,
  compare: 'greater',
});
try {
renderPassEncoder15.setBindGroup(3, bindGroup104, new Uint32Array(7886), 33, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(2_679).fill(62), /* required buffer size: 2_679 */
{offset: 299, bytesPerRow: 5, rowsPerImage: 59}, {width: 0, height: 5, depthOrArrayLayers: 9});
} catch {}
await gc();
let offscreenCanvas5 = new OffscreenCanvas(93, 143);
let commandEncoder241 = device0.createCommandEncoder({});
try {
computePassEncoder19.setBindGroup(2, bindGroup88, new Uint32Array(5627), 2_614, 0);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(36);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer77, 'uint16', 1_322, 742);
} catch {}
try {
querySet20.destroy();
} catch {}
try {
commandEncoder240.copyTextureToBuffer({
  texture: texture229,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 464 */
  offset: 464,
  rowsPerImage: 106,
  buffer: buffer151,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = computePassEncoder145.label;
} catch {}
let computePassEncoder197 = commandEncoder229.beginComputePass({});
let sampler139 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 99.27,
});
try {
renderPassEncoder17.setBindGroup(0, bindGroup73);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup121, new Uint32Array(920), 453, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer176, 0, 4_845);
} catch {}
try {
commandEncoder241.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1276 */
  offset: 1276,
  bytesPerRow: 19200,
  buffer: buffer44,
}, {
  texture: texture103,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer18, 448, new DataView(new ArrayBuffer(33597)), 7526, 1104);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 151, y: 0, z: 25},
  aspect: 'all',
}, new Uint8Array(112).fill(235), /* required buffer size: 112 */
{offset: 112, bytesPerRow: 464}, {width: 18, height: 0, depthOrArrayLayers: 1});
} catch {}
let computePassEncoder198 = commandEncoder241.beginComputePass({});
try {
computePassEncoder140.setBindGroup(1, bindGroup66);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup91);
} catch {}
try {
renderPassEncoder44.setBindGroup(1, bindGroup138, new Uint32Array(1276), 4, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder30.setScissorRect(1, 2, 9, 4);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(3, buffer97, 2_456);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 102}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture253,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 21},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
let bindGroup142 = device0.createBindGroup({
  label: '\u678c\u0de7\u09de\u0c78\u0d80',
  layout: bindGroupLayout6,
  entries: [
    {binding: 0, resource: sampler32},
    {binding: 309, resource: {buffer: buffer33, offset: 256, size: 3680}},
    {binding: 193, resource: sampler115},
    {binding: 420, resource: sampler0},
    {binding: 90, resource: externalTexture22},
    {binding: 153, resource: textureView110},
    {binding: 61, resource: {buffer: buffer102, offset: 512, size: 9587}},
    {binding: 56, resource: externalTexture15},
    {binding: 76, resource: {buffer: buffer17, offset: 1536, size: 1216}},
    {binding: 65, resource: textureView266},
    {binding: 280, resource: sampler0},
    {binding: 46, resource: textureView123},
    {binding: 137, resource: {buffer: buffer1, offset: 768, size: 859}},
    {binding: 130, resource: {buffer: buffer22, offset: 2816, size: 1207}},
    {binding: 388, resource: textureView1},
    {binding: 19, resource: textureView1},
    {binding: 134, resource: externalTexture7},
    {binding: 104, resource: textureView237},
    {binding: 98, resource: {buffer: buffer165, offset: 768, size: 718}},
    {binding: 191, resource: sampler99},
    {binding: 107, resource: {buffer: buffer61, offset: 2816, size: 585}},
    {binding: 81, resource: textureView110},
    {binding: 45, resource: sampler94},
    {binding: 68, resource: sampler40},
    {binding: 64, resource: {buffer: buffer48, offset: 0, size: 168}},
    {binding: 381, resource: {buffer: buffer95, offset: 1536, size: 3228}},
    {binding: 158, resource: textureView79},
    {binding: 216, resource: sampler137},
    {binding: 177, resource: sampler135},
    {binding: 67, resource: externalTexture13},
    {binding: 21, resource: {buffer: buffer163, offset: 0, size: 620}},
    {binding: 119, resource: externalTexture22},
    {binding: 8, resource: sampler42},
    {binding: 525, resource: {buffer: buffer80, offset: 512}},
    {binding: 307, resource: {buffer: buffer98, offset: 0, size: 2603}},
    {binding: 133, resource: sampler119},
    {binding: 44, resource: sampler138},
    {binding: 51, resource: {buffer: buffer83, offset: 2048}},
    {binding: 146, resource: {buffer: buffer20, offset: 3840, size: 1040}},
    {binding: 132, resource: {buffer: buffer141, offset: 512, size: 2024}},
    {binding: 128, resource: {buffer: buffer5, offset: 4096}},
    {binding: 66, resource: textureView255},
    {binding: 114, resource: textureView135},
    {binding: 35, resource: textureView110},
    {binding: 58, resource: textureView252},
    {binding: 22, resource: {buffer: buffer79, offset: 1024, size: 5872}},
    {binding: 18, resource: sampler57},
    {binding: 59, resource: textureView113},
    {binding: 384, resource: {buffer: buffer95, offset: 512, size: 2424}},
    {binding: 217, resource: textureView55},
    {binding: 20, resource: {buffer: buffer91, offset: 768, size: 3834}},
    {binding: 136, resource: textureView108},
    {binding: 87, resource: sampler63},
    {binding: 413, resource: textureView64},
    {binding: 84, resource: externalTexture11},
    {binding: 201, resource: textureView52},
    {binding: 160, resource: sampler20},
    {binding: 75, resource: textureView105},
    {binding: 140, resource: textureView238},
    {binding: 161, resource: {buffer: buffer13, offset: 1536, size: 9122}},
    {binding: 29, resource: textureView100},
    {binding: 154, resource: sampler110},
  ],
});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 0, y: 18 },
  flipY: false,
}, {
  texture: texture167,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer184 = device0.createBuffer({
  size: 1561,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
commandEncoder240.copyTextureToTexture({
  texture: texture240,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture76,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer179, 800, new Int16Array(25368), 10164, 520);
} catch {}
document.body.prepend(img0);
let bindGroupLayout34 = device0.createBindGroupLayout({
  label: '\u2671\u0736\udae4\u3b35\u{1f8cc}\udc16\uc1f5\u07fe',
  entries: [
    {
      binding: 278,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let sampler140 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMinClamp: 46.80,
  lodMaxClamp: 52.36,
});
try {
computePassEncoder4.setBindGroup(0, bindGroup130);
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
renderPassEncoder20.setVertexBuffer(7, buffer37, 0);
} catch {}
let bindGroup143 = device0.createBindGroup({layout: bindGroupLayout34, entries: [{binding: 278, resource: textureView220}]});
let texture275 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 128},
  dimension: '3d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder199 = commandEncoder240.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(2, 1, 1); };
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup8, new Uint32Array(641), 27, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer72);
} catch {}
try {
commandEncoder3.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 336 */
  offset: 336,
  bytesPerRow: 2816,
  rowsPerImage: 122,
  buffer: buffer103,
}, {
  texture: texture271,
  mipLevel: 0,
  origin: {x: 22, y: 21, z: 0},
  aspect: 'all',
}, {width: 6, height: 25, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder3.copyTextureToTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 66, y: 1, z: 6},
  aspect: 'all',
},
{
  texture: texture34,
  mipLevel: 0,
  origin: {x: 49, y: 0, z: 1},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 136, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(193).fill(1), /* required buffer size: 193 */
{offset: 193, rowsPerImage: 75}, {width: 98, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise25 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 1}
*/
{
  source: videoFrame34,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture66,
  mipLevel: 1,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer185 = device0.createBuffer({size: 20368, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder242 = device0.createCommandEncoder({});
let textureView281 = texture71.createView({baseMipLevel: 0, arrayLayerCount: 1});
let texture276 = device0.createTexture({
  size: [13],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder200 = commandEncoder242.beginComputePass({});
let externalTexture32 = device0.importExternalTexture({source: videoFrame20});
try {
computePassEncoder182.setBindGroup(3, bindGroup21);
} catch {}
try {
renderPassEncoder25.setBindGroup(1, bindGroup115, new Uint32Array(1872), 32, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline3);
} catch {}
try {
commandEncoder3.copyBufferToBuffer(buffer148, 1984, buffer137, 992, 2044);
} catch {}
let buffer186 = device0.createBuffer({label: '\ue15a\u{1fb5d}', size: 37517, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder243 = device0.createCommandEncoder({});
let texture277 = device0.createTexture({size: [13, 2, 32], format: 'stencil8', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
let textureView282 = texture146.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3});
let computePassEncoder201 = commandEncoder243.beginComputePass({label: '\u0a9f\u3516\u06eb\u01d4\u{1fc31}\u5e9e\u{1f6b7}'});
try {
computePassEncoder187.setBindGroup(3, bindGroup67, new Uint32Array(3600), 680, 0);
} catch {}
try {
renderPassEncoder42.setBindGroup(3, bindGroup19, new Uint32Array(1234), 335, 0);
} catch {}
try {
renderPassEncoder16.setViewport(21.1186790954772, 37.0369272209837, 22.821728700166158, 2.327397141616084, 0.5176191611126639, 0.7025846261023094);
} catch {}
try {
commandEncoder3.copyBufferToBuffer(buffer156, 360, buffer62, 4624, 6024);
} catch {}
try {
commandEncoder3.clearBuffer(buffer171);
} catch {}
let commandEncoder244 = device0.createCommandEncoder({});
let texture278 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder202 = commandEncoder3.beginComputePass({});
try {
computePassEncoder124.setBindGroup(0, bindGroup27, new Uint32Array(580), 12, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder124); computePassEncoder124.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder178.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder35.setBindGroup(1, bindGroup99);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer48, 'uint32', 116, 74);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline1);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 27}
*/
{
  source: imageBitmap6,
  origin: { x: 8, y: 0 },
  flipY: true,
}, {
  texture: texture205,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext10 = offscreenCanvas5.getContext('webgpu');
await gc();
let img1 = await imageWithData(19, 66, '#10101010', '#20202020');
let texture279 = device0.createTexture({size: [161, 1, 1], format: 'stencil8', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder203 = commandEncoder244.beginComputePass({});
try {
computePassEncoder51.setBindGroup(3, bindGroup52);
} catch {}
try {
computePassEncoder176.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder38.setBindGroup(0, bindGroup60, []);
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup3, new Uint32Array(910), 73, 0);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(1, buffer11, 520);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame35,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture238,
  mipLevel: 0,
  origin: {x: 20, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder245 = device0.createCommandEncoder({});
let textureView283 = texture270.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder204 = commandEncoder245.beginComputePass();
let sampler141 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.59,
  lodMaxClamp: 98.84,
  maxAnisotropy: 7,
});
try {
computePassEncoder112.setBindGroup(2, bindGroup80);
} catch {}
try {
computePassEncoder130.setBindGroup(3, bindGroup4, new Uint32Array(367), 62, 0);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(116);
} catch {}
try {
  await promise25;
} catch {}
let bindGroup144 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 7, resource: textureView276},
    {binding: 112, resource: sampler137},
    {binding: 29, resource: textureView26},
    {binding: 136, resource: textureView265},
    {binding: 124, resource: textureView184},
  ],
});
let texture280 = device0.createTexture({
  size: {width: 55, height: 8, depthOrArrayLayers: 1},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView284 = texture3.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 3});
try {
computePassEncoder140.setBindGroup(3, bindGroup109, []);
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup93, []);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup47, new Uint32Array(4701), 152, 0);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
buffer73.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas4);
let sampler142 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 28.61,
  lodMaxClamp: 73.07,
});
try {
computePassEncoder160.setBindGroup(3, bindGroup141);
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup124, new Uint32Array(4031), 674, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer138, 0, 406);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await promise24;
} catch {}
let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder246 = device0.createCommandEncoder({});
let computePassEncoder205 = commandEncoder246.beginComputePass({});
try {
computePassEncoder50.setBindGroup(3, bindGroup42);
} catch {}
try {
computePassEncoder60.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline1);
} catch {}
let buffer187 = device0.createBuffer({
  label: '\u0ba3\u01c1\u1740',
  size: 39804,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture281 = device0.createTexture({
  size: [52, 40, 64],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView285 = texture276.createView({});
let sampler143 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 23.80,
  lodMaxClamp: 72.62,
  maxAnisotropy: 14,
});
try {
computePassEncoder136.setBindGroup(3, bindGroup86, new Uint32Array(1149), 405, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer75, 0, 5_102);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder94.setBindGroup(2, bindGroup112, new Uint32Array(677), 159, 0);
} catch {}
try {
computePassEncoder137.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder35.setBindGroup(1, bindGroup27, new Uint32Array(326), 10, 0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle28, renderBundle5, renderBundle2, renderBundle14]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer121);
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(1) @binding(2) var tex52: texture_2d<f32>;

@group(1) @binding(5) var st16: texture_storage_3d<rg32float, write>;

@group(1) @binding(8) var tex53: texture_cube<f32>;

@group(1) @binding(15) var tex54: texture_depth_2d;

@group(1) @binding(20) var et10: texture_external;

@group(1) @binding(29) var sam14: sampler_comparison;

@group(1) @binding(33) var st17: texture_storage_1d<rgba8uint, write>;

@group(1) @binding(34) var sam15: sampler;

@group(1) @binding(36) var sam16: sampler;

@group(1) @binding(38) var sam17: sampler;

@group(1) @binding(47) var sam18: sampler;

@group(1) @binding(49) var<storage, read_write> buffer188: array<i32, 368>;

@group(1) @binding(54) var et11: texture_external;

@group(1) @binding(55) var<storage, read> buffer189: array<array<vec2h, 9>>;

@group(1) @binding(61) var st18: texture_storage_1d<bgra8unorm, write>;

@group(1) @binding(62) var sam19: sampler_comparison;

@group(1) @binding(65) var tex55: texture_depth_2d;

@group(1) @binding(67) var tex56: texture_2d<f32>;

@group(1) @binding(68) var<storage, read_write> buffer190: array<array<array<array<f16, 3>, 1>, 23>>;

@group(1) @binding(95) var sam20: sampler;

@group(1) @binding(99) var<uniform> buffer191: i32;

@group(1) @binding(112) var tex57: texture_cube<f32>;

@group(1) @binding(117) var<uniform> buffer192: mat2x2h;

@group(1) @binding(118) var tex58: texture_depth_2d;

@group(1) @binding(125) var tex59: texture_depth_2d;

@group(1) @binding(135) var et12: texture_external;

@group(1) @binding(141) var tex60: texture_cube<u32>;

@group(1) @binding(142) var tex61: texture_1d<u32>;

@group(1) @binding(161) var tex62: texture_2d<f32>;

@group(1) @binding(195) var tex63: texture_2d<u32>;

@group(1) @binding(209) var tex64: texture_2d<u32>;

@group(1) @binding(216) var<uniform> buffer193: array<array<mat4x2h, 102>, 1>;

@group(1) @binding(228) var<storage, read> buffer194: array<array<array<array<array<array<f16, 1>, 7>, 1>, 1>, 2>, 112>;

@group(1) @binding(232) var<storage, read> buffer195: array<array<array<f16, 7>, 56>>;

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

@group(1) @binding(328) var tex65: texture_2d<u32>;

@group(1) @binding(330) var<uniform> buffer197: f32;

@group(1) @binding(348) var tex66: texture_2d<u32>;

@group(1) @binding(384) var et13: texture_external;

@group(1) @binding(408) var tex67: texture_1d<u32>;

@group(1) @binding(479) var et14: texture_external;

@group(1) @binding(697) var<storage, read_write> buffer198: VertexOutput8;

@group(1) @binding(712) var<storage, read> buffer199: array<array<array<array<f16, 7>, 2>, 16>>;

struct T0 {
  @size(320) f0: mat2x4f,
}

struct T1 {
  f0: vec2u,
}

struct T2 {
  @size(312) f0: array<mat2x2f, 1>,
}

struct VertexOutput8 {
  @invariant @builtin(position) f29: vec4f,
}

struct S4 {
  @location(3) f0: f32,
}

struct S5 {
  @location(14) @interpolate(flat) f0: u32,
  @location(15) f1: vec2i,
  @location(5) f2: vec2i,
}

alias vec3b = vec3<bool>;

@id(45624) override override15: f16;

override override16 = 0.1122;

override override17 = 0.05831;

@id(13893) override override18: f32;

override override19: bool;

fn fn0(a0: array<vec4i, 1>, a1: T1) -> array<VertexOutput8, 1> {
  var out: array<VertexOutput8, 1>;
  textureStore(st17, i32(unconst_i32(123)), vec4u(vec4u(unconst_u32(141), unconst_u32(2), unconst_u32(41), unconst_u32(44))));
  let ptr103: ptr<storage, f16, read> = &buffer199[u32(unconst_u32(24))][15][1][u32(unconst_u32(293))];
  var vf96: vec4f = textureLoad(tex56, vec2i(unconst_i32(113), unconst_i32(117)), i32(unconst_i32(103)));
  textureStore(st17, i32(unconst_i32(176)), vec4u(vec4u(unconst_u32(34), unconst_u32(8), unconst_u32(82), unconst_u32(71))));
  let ptr104: ptr<uniform, i32> = &buffer191;
  let ptr105: ptr<storage, array<f16, 3>, read_write> = &(*&buffer190)[u32(unconst_u32(62))][22][0];
  var vf97: vec4u = textureGather(200 % 4, tex66, sam20, vec2f(unconst_f32(0.2829), unconst_f32(0.09480)));
  let ptr106: ptr<storage, f16, read> = &(*&buffer199)[arrayLength(&(*&buffer199))][u32(unconst_u32(318))][u32(unconst_u32(44))][u32(unconst_u32(129))];
  buffer198 = VertexOutput8(textureGatherCompare(tex58, sam14, vec2f(unconst_f32(0.1859), unconst_f32(0.3022)), f32(unconst_f32(0.1320))));
  textureStore(st18, i32(unconst_i32(82)), vec4f(vec4f(unconst_f32(0.1741), unconst_f32(0.3013), unconst_f32(0.08486), unconst_f32(0.05655))));
  buffer198.f29 = vec4f(f32(buffer190[arrayLength(&buffer190)][22][0][2]));
  var vf98: f32 = textureSampleCompareLevel(tex58, sam14, vec2f(unconst_f32(-0.05320), unconst_f32(0.1701)), textureSampleLevel(tex59, sam20, vec2f(unconst_f32(0.07826), unconst_f32(-0.02461)), i32(unconst_i32(508)), clamp(vec2i(631, -401), vec2i(-8), vec2i(7))));
  buffer188[u32(unconst_u32(49))] *= i32(buffer199[u32(unconst_u32(512))][u32(unconst_u32(29))][textureDimensions(tex58, i32(unconst_i32(1000))).x][6]);
  let ptr107: ptr<storage, vec2h, read> = &buffer189[u32(unconst_u32(32))][8];
  buffer190[u32(unconst_u32(76))][u32(unconst_u32(310))][u32(unconst_u32(0))][u32(unconst_u32(556))] = buffer199[arrayLength(&buffer199)][15][u32(unconst_u32(32))][6];
  textureStore(st18, i32(unconst_i32(11)), vec4f(vec4f(unconst_f32(-0.3216), unconst_f32(0.00737), unconst_f32(0.1000), unconst_f32(0.01022))));
  buffer198.f29 += vec4f((*&buffer189)[u32(unconst_u32(49))][8].xyyx);
  let ptr108: ptr<storage, f16, read_write> = &(*&buffer190)[arrayLength(&(*&buffer190))][u32(unconst_u32(498))][0][2];
  return out;
}

var<private> vp4 = modf(f32(0.1124));

@vertex
fn vertex9() -> VertexOutput8 {
  var out: VertexOutput8;
  out.f29 = textureGather(73 % 4, tex56, sam18, vec2f(unconst_f32(0.05546), unconst_f32(0.1564)));
  let ptr109: ptr<storage, f16, read> = &(*&buffer194)[111][1][0][u32(unconst_u32(513))][6][u32(unconst_u32(300))];
  vp4 = modf(override16);
  vp4 = modf(textureLoad(et14, vec2u(unconst_u32(526), unconst_u32(133)))[2]);
  out.f29 = vec4f(f32((*&buffer194)[111][u32(unconst_u32(345))][u32(unconst_u32(123))][0][u32((*&buffer194)[111][1][0][0][6][0])][0]));
  vp4 = modf(f32((*&buffer194)[u32(unconst_u32(29))][1][0][u32((*&buffer194)[111][u32(unconst_u32(97))][u32(unconst_u32(41))][0][6][u32((*&buffer194)[u32(unconst_u32(167))][u32(unconst_u32(861))][u32(unconst_u32(94))][u32((*&buffer194)[111][u32(unconst_u32(54))][0][0][u32(unconst_u32(29))][u32(unconst_u32(44))])][pack4x8unorm(textureLoad(et12, vec2u(unconst_u32(470), unconst_u32(52))))][0])])][6][u32(unconst_u32(125))]));
  let ptr110: ptr<storage, array<array<f16, 1>, 7>, read> = &(*&buffer194)[u32(buffer194[u32(buffer194[111][u32(unconst_u32(53))][u32(unconst_u32(243))][0][6][u32(unconst_u32(145))])][1][u32(unconst_u32(72))][0][u32(unconst_u32(372))][0])][1][0][0];
  let ptr111: ptr<storage, array<array<f16, 1>, 7>, read> = &(*&buffer194)[111][1][0][0];
  let ptr112: ptr<storage, array<f16, 1>, read> = &(*ptr110)[u32(unconst_u32(28))];
  out.f29 = textureSampleLevel(tex52, sam15, vec2f(unconst_f32(0.2857), unconst_f32(0.01652)), f32(unconst_f32(0.01000)), clamp(vec2i(32, 138), vec2i(-8), vec2i(7)));
  let ptr113: ptr<storage, f16, read> = &buffer194[111][u32((*&buffer194)[111][1][u32(unconst_u32(11))][u32(unconst_u32(61))][6][0])][0][u32(unconst_u32(39))][u32(unconst_u32(37))][0];
  let ptr114: ptr<storage, f16, read> = &buffer194[111][u32(unconst_u32(88))][u32((*&buffer194)[111][u32(unconst_u32(315))][0][u32(unconst_u32(55))][u32((*&buffer194)[u32(unconst_u32(441))][u32(buffer194[u32(unconst_u32(77))][1][u32(unconst_u32(56))][u32(unconst_u32(99))][u32(unconst_u32(15))][0])][0][0][u32(unconst_u32(39))][u32(unconst_u32(152))])][0])][u32(unconst_u32(63))][u32(unconst_u32(160))][0];
  let ptr115: ptr<storage, f16, read> = &buffer194[u32(unconst_u32(44))][u32(unconst_u32(92))][u32(unconst_u32(228))][u32(unconst_u32(439))][u32(unconst_u32(338))][u32(unconst_u32(54))];
  out.f29 += vec4f(f32(buffer194[u32(unconst_u32(798))][1][0][u32(unconst_u32(207))][u32(unconst_u32(82))][0]));
  out.f29 = vec4f(f32(buffer194[u32(unconst_u32(3))][1][0][0][6][0]));
  let ptr116: ptr<storage, array<f16, 1>, read> = &buffer194[u32(unconst_u32(442))][u32(unconst_u32(12))][u32(unconst_u32(145))][0][6];
  let ptr117: ptr<storage, array<f16, 1>, read> = &buffer194[111][1][0][u32(unconst_u32(28))][u32(unconst_u32(190))];
  return out;
  _ = override16;
}

@fragment
fn fragment5(a0: S4, @location(7) a1: vec4u, a2: S5) -> @location(200) vec4u {
  var out: vec4u;
  let ptr118: ptr<storage, f16, read_write> = &buffer190[u32(unconst_u32(266))][u32(unconst_u32(264))][0][2];
  let ptr119: ptr<storage, array<array<f16, 3>, 1>, read_write> = &buffer190[arrayLength(&buffer190)][22];
  buffer196[u32(unconst_u32(357))] = (*&buffer190)[arrayLength(&(*&buffer190))][u32(unconst_u32(56))][0][2];
  textureStore(st16, vec3i(bitcast<i32>(override16)), vec4f(vec4f(unconst_f32(0.00312), unconst_f32(0.1674), unconst_f32(0.09819), unconst_f32(0.1022))));
  buffer190[u32(unconst_u32(58))][22][u32(unconst_u32(388))][u32(unconst_u32(49))] = buffer190[u32(unconst_u32(0))][22][0][2];
  let vf99: vec4f = textureGather(tex55, sam15, vec2f(unconst_f32(0.1654), unconst_f32(0.4357)));
  var vf100: vec4f = textureGather(115 % 4, tex56, sam20, vec2f(unconst_f32(0.2953), unconst_f32(0.00546)));
  let vf101: f32 = textureSample(tex55, sam20, vec2f(unconst_f32(0.01534), unconst_f32(0.02494)));
  let vf102: vec4f = textureGather(tex58, sam15, vec2f(unconst_f32(0.1710), unconst_f32(0.06748)), clamp(vec2i(153, 72), vec2i(-8), vec2i(7)));
  buffer196[u32(unconst_u32(75))] *= (*&buffer190)[u32(unconst_u32(73))][22][u32(unconst_u32(323))][2];
  textureStore(st16, vec3i(unconst_i32(56), unconst_i32(38), unconst_i32(29)), vec4f(vec4f(unconst_f32(0.1774), unconst_f32(0.2935), unconst_f32(0.2570), unconst_f32(0.1800))));
  let ptr120: ptr<storage, f16, read_write> = &buffer190[arrayLength(&buffer190)][22][pack4x8unorm(textureSampleBaseClampToEdge(tex62, sam15, vec2f(unconst_f32(0.01139), unconst_f32(0.02956))))][u32(unconst_u32(377))];
  let vf103: vec4f = textureLoad(et11, vec2u(unconst_u32(365), unconst_u32(236)));
  buffer190[u32(unconst_u32(626))][pack4xU8Clamp(textureGather(109 % 4, tex64, sam15, vec2f(unconst_f32(0.1948), unconst_f32(0.00403)), clamp(vec2i(132, 333), vec2i(-8), vec2i(7))))][u32(unconst_u32(2))][u32(unconst_u32(174))] = f16(vf99[2]);
  var vf104: vec2f = quantizeToF16(vec2f(unconst_f32(0.01653), unconst_f32(0.1555)));
  let ptr121: ptr<storage, array<array<f16, 3>, 1>, read_write> = &buffer190[u32(unconst_u32(176))][u32(unconst_u32(51))];
  let vf105: vec2u = textureDimensions(tex63, i32(unconst_i32(125)));
  return out;
  _ = override16;
}

@compute @workgroup_size(1, 1, 2)
fn compute6() {
  buffer198 = VertexOutput8(vec4f(f32(buffer199[arrayLength(&buffer199)][15][1][6])));
  let ptr122: ptr<storage, f16, read> = &(*&buffer199)[textureDimensions(tex54, i32(unconst_i32(-670)))[0]][u32(unconst_u32(443))][1][u32(unconst_u32(6))];
  var vf106 = fn0(array<vec4i, 1>(vec4i(i32(textureSampleCompareLevel(tex59, sam14, vec2f(unconst_f32(-0.00075), unconst_f32(0.02027)), f32(unconst_f32(-0.03977)))))), T1(vec2u(u32((*&buffer199)[arrayLength(&(*&buffer199))][15][1][6]))));
  buffer188[u32(unconst_u32(240))] = bitcast<i32>((*&buffer189)[arrayLength(&(*&buffer189))][u32(unconst_u32(30))]);
  buffer188[367] = i32(buffer190[u32(unconst_u32(1))][u32(unconst_u32(19))][bitcast<u32>(buffer189[arrayLength(&buffer189)][u32(unconst_u32(329))])][2]);
  let vf107: bool = override19;
  _ = override19;
}

@compute @workgroup_size(1, 1, 2)
fn compute7() {
  fn0(array<vec4i, 1>(unpack4xI8(textureDimensions(tex61, 0i))), T1(vec2u(u32(buffer190[arrayLength(&buffer190)][u32(unconst_u32(100))][u32(unconst_u32(88))][2]))));
}`,
  hints: {},
});
try {
renderPassEncoder7.setBindGroup(0, bindGroup57);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle6, renderBundle14, renderBundle7, renderBundle28]);
} catch {}
let arrayBuffer18 = buffer90.getMappedRange(8432, 60);
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture237,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup145 = device0.createBindGroup({
  layout: bindGroupLayout32,
  entries: [
    {binding: 17, resource: {buffer: buffer89, offset: 3328, size: 4110}},
    {binding: 338, resource: {buffer: buffer137, offset: 1536, size: 140}},
  ],
});
let commandEncoder247 = device0.createCommandEncoder({label: '\u{1f655}\u3143\u00cd\uf6de\u016c\u{1f600}\u236e'});
let textureView286 = texture160.createView({label: '\uf14c\u027d\ub15c\u4b0d\uab07', dimension: '2d-array'});
let texture282 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 42},
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder206 = commandEncoder247.beginComputePass({});
try {
computePassEncoder201.setBindGroup(3, bindGroup112, new Uint32Array(1153), 11, 0);
} catch {}
try {
globalThis.someLabel = externalTexture7.label;
} catch {}
let commandEncoder248 = device0.createCommandEncoder();
let texture283 = device0.createTexture({
  size: [13, 2, 1],
  mipLevelCount: 1,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView287 = texture138.createView({format: 'rgba8uint'});
let computePassEncoder207 = commandEncoder248.beginComputePass({});
try {
renderPassEncoder43.setVertexBuffer(2, buffer74, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer145, 1716, new Float32Array(4225), 0, 428);
} catch {}
document.body.prepend(canvas1);
try {
computePassEncoder161.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup50, new Uint32Array(1471), 78, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer11, 'uint32', 1_296, 72);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer177, 1_044, 275);
} catch {}
let arrayBuffer19 = buffer90.getMappedRange(8344, 8);
try {
buffer39.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer141, 2256, new Int16Array(8866), 314, 836);
} catch {}
let bindGroup146 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 293, resource: textureView284}]});
let buffer200 = device0.createBuffer({size: 17922, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder249 = device0.createCommandEncoder({});
let computePassEncoder208 = commandEncoder249.beginComputePass();
try {
computePassEncoder92.setBindGroup(3, bindGroup16, new Uint32Array(1571), 52, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder15.setBlendConstant({ r: -552.9, g: -237.7, b: -595.7, a: -571.4, });
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer17, 'uint32', 2_324, 4_138);
} catch {}
let bindGroup147 = device0.createBindGroup({
  label: '\u{1f8ed}\ue703\u717a\uf06f\u77ca\u01c0',
  layout: bindGroupLayout3,
  entries: [{binding: 593, resource: textureView11}],
});
let commandEncoder250 = device0.createCommandEncoder({});
let computePassEncoder209 = commandEncoder250.beginComputePass();
try {
renderPassEncoder22.setBindGroup(3, bindGroup141);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle14]);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let videoFrame40 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470m', transfer: 'linear'} });
try {
computePassEncoder57.setBindGroup(2, bindGroup86, new Uint32Array(8401), 1_281, 0);
} catch {}
try {
computePassEncoder68.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(0, buffer2, 0, 2_292);
} catch {}
let offscreenCanvas6 = new OffscreenCanvas(332, 36);
let commandEncoder251 = device0.createCommandEncoder({});
let textureView288 = texture276.createView({
  label: '\u0318\u08c6\u{1ff8a}\uf447\u3903\u{1fb6d}\u{1fa8a}\u38a0\uca3b\ub589\u633f',
  arrayLayerCount: 1,
});
let sampler144 = device0.createSampler({
  label: '\u{1fc4c}\u066a\u{1fc6e}\u03c2\u{1fb87}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 74.02,
  lodMaxClamp: 93.83,
});
try {
renderPassEncoder47.setBindGroup(3, bindGroup36);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer101, 'uint32', 72, 79);
} catch {}
try {
renderPassEncoder21.insertDebugMarker('\u0468');
} catch {}
let commandEncoder252 = device0.createCommandEncoder({});
let texture284 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView289 = texture245.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 2, baseArrayLayer: 2, arrayLayerCount: 1});
try {
computePassEncoder46.setBindGroup(1, bindGroup14);
} catch {}
try {
renderPassEncoder48.setBindGroup(1, bindGroup33, new Uint32Array(927), 84, 0);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame32,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup148 = device0.createBindGroup({
  layout: bindGroupLayout20,
  entries: [{binding: 27, resource: sampler86}, {binding: 259, resource: {buffer: buffer187, offset: 23552}}],
});
let buffer201 = device0.createBuffer({size: 6461, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder253 = device0.createCommandEncoder({});
let textureView290 = texture60.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder5.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup35, new Uint32Array(569), 42, 0);
} catch {}
try {
commandEncoder251.copyBufferToTexture({
  /* bytesInLastRow: 1632 widthInBlocks: 204 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4536 */
  offset: 4536,
  bytesPerRow: 1792,
  buffer: buffer66,
}, {
  texture: texture88,
  mipLevel: 0,
  origin: {x: 254, y: 1, z: 0},
  aspect: 'all',
}, {width: 204, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture285 = device0.createTexture({size: [161], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST});
let textureView291 = texture201.createView({label: '\u{1fdd1}\uba31'});
try {
computePassEncoder129.setBindGroup(0, bindGroup95, new Uint32Array(3217), 99, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder42); computePassEncoder42.dispatchWorkgroupsIndirect(buffer56, 4); };
} catch {}
try {
computePassEncoder53.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder32.beginOcclusionQuery(37);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(3, undefined, 2_376_853_529, 38_387_779);
} catch {}
try {
commandEncoder251.copyBufferToTexture({
  /* bytesInLastRow: 68 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3028 */
  offset: 3028,
  buffer: buffer94,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 35, y: 0, z: 0},
  aspect: 'all',
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let commandEncoder254 = device0.createCommandEncoder({});
let textureView292 = texture241.createView({label: '\u{1ff17}\u0ba8', mipLevelCount: 1});
let sampler145 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 97.12,
});
try {
{ clearResourceUsages(device0, computePassEncoder124); computePassEncoder124.dispatchWorkgroupsIndirect(buffer158, 104); };
} catch {}
try {
commandEncoder254.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1294 */
  offset: 1294,
  rowsPerImage: 464,
  buffer: buffer122,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let videoFrame41 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} });
let computePassEncoder210 = commandEncoder251.beginComputePass({});
let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder196.setBindGroup(3, bindGroup48, new Uint32Array(405), 26, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(1, buffer154);
} catch {}
try {
renderBundleEncoder37.setBindGroup(3, bindGroup81, new Uint32Array(2201), 603, 0);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(5, buffer38, 488, 129);
} catch {}
let offscreenCanvas7 = new OffscreenCanvas(502, 108);
let bindGroup149 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 293, resource: textureView109}]});
let commandEncoder255 = device0.createCommandEncoder({});
let computePassEncoder211 = commandEncoder253.beginComputePass({});
try {
computePassEncoder48.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup106, new Uint32Array(2087), 652, 0);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(5, undefined);
} catch {}
try {
commandEncoder254.copyBufferToTexture({
  /* bytesInLastRow: 5264 widthInBlocks: 329 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 224 */
  offset: 224,
  bytesPerRow: 10240,
  rowsPerImage: 376,
  buffer: buffer9,
}, {
  texture: texture83,
  mipLevel: 1,
  origin: {x: 17, y: 2, z: 0},
  aspect: 'all',
}, {width: 329, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext11 = offscreenCanvas6.getContext('webgpu');
let imageData34 = new ImageData(36, 8);
try {
globalThis.someLabel = externalTexture15.label;
} catch {}
let commandEncoder256 = device0.createCommandEncoder();
let computePassEncoder212 = commandEncoder256.beginComputePass({});
let renderBundle37 = renderBundleEncoder37.finish({});
let sampler146 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 95.06,
});
try {
computePassEncoder166.setBindGroup(1, bindGroup95);
} catch {}
try {
computePassEncoder94.setBindGroup(2, bindGroup118, new Uint32Array(3914), 193, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder124); computePassEncoder124.dispatchWorkgroupsIndirect(buffer56, 468); };
} catch {}
try {
computePassEncoder59.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer8, 'uint32', 600, 1_853);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let arrayBuffer20 = buffer71.getMappedRange(32, 4);
try {
buffer185.unmap();
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u079e');
} catch {}
try {
device0.queue.writeBuffer(buffer12, 1048, new BigUint64Array(6478), 11, 552);
} catch {}
let pipeline4 = device0.createRenderPipeline({
  layout: pipelineLayout9,
  multisample: {count: 4},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment4',
  targets: [{format: 'rg16uint', writeMask: 0}, {
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'constant', dstFactor: 'dst-alpha'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rgba16uint'}, {format: 'bgra8unorm-srgb', writeMask: 0}, {
  format: 'rgba16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-constant'},
  },
  writeMask: 0,
}, {
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {module: shaderModule7, buffers: []},
});
let bindGroup150 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [
    {binding: 46, resource: textureView169},
    {binding: 197, resource: {buffer: buffer40, offset: 768, size: 1076}},
  ],
});
let commandEncoder257 = device0.createCommandEncoder({});
let computePassEncoder213 = commandEncoder255.beginComputePass({});
try {
computePassEncoder39.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup105, []);
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup22, new Uint32Array(2902), 47, 0);
} catch {}
try {
renderPassEncoder32.endOcclusionQuery();
} catch {}
try {
renderPassEncoder34.setViewport(9.22480370403115, 3.1584602710596963, 0.3947244119072418, 5.119076835435346, 0.05998656413377712, 0.9114172933451407);
} catch {}
try {
commandEncoder252.copyBufferToBuffer(buffer90, 6912, buffer79, 11788, 1164);
} catch {}
try {
  await promise26;
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let shaderModule8 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer202: vec2u;

@group(0) @binding(38) var st19: texture_storage_3d<rg32float, write>;

@group(0) @binding(41) var<storage, read> buffer203: array<array<array<array<f16, 1>, 1>, 2>>;

@group(0) @binding(107) var tex68: texture_1d<u32>;

@group(0) @binding(115) var tex69: texture_1d<i32>;

@group(0) @binding(245) var st20: texture_storage_3d<r32uint, read>;

@group(0) @binding(268) var tex70: texture_2d_array<u32>;

@group(0) @binding(296) var tex71: texture_2d<u32>;

struct T0 {
  f0: vec2f,
}

struct S6 {
  @location(1) f0: vec4u,
  @location(13) f1: vec2i,
  @location(3) @interpolate(perspective) f2: f16,
}

struct VertexOutput9 {
  @builtin(position) f30: vec4f,
}

struct VertexOutput10 {
  @location(10) f31: vec4h,
  @location(2) f32: vec2f,
  @builtin(position) f33: vec4f,
}

struct FragmentOutput4 {
  @location(6) f0: vec4i,
  @location(0) f1: vec2i,
}

fn fn0() -> vec4i {
  var out: vec4i;
  let vf108: u32 = textureNumLevels(tex71);
  var vf109: vec2u = textureDimensions(tex71);
  let ptr123: ptr<storage, f16, read> = &(*&buffer203)[arrayLength(&(*&buffer203))][u32(unconst_u32(3))][u32(unconst_u32(304))][u32(unconst_u32(19))];
  let ptr124: ptr<storage, array<array<f16, 1>, 1>, read> = &buffer203[arrayLength(&buffer203)][u32(unconst_u32(427))];
  textureStore(st19, vec3i(unconst_i32(216), unconst_i32(-15), unconst_i32(-961)), vec4f(vec4f(unconst_f32(0.3521), unconst_f32(-0.1263), unconst_f32(0.03667), unconst_f32(0.08133))));
  let ptr125: ptr<storage, f16, read> = &(*&buffer203)[arrayLength(&(*&buffer203))][1][u32(unconst_u32(335))][u32(unconst_u32(1))];
  out &= vec4i(i32((*&buffer203)[u32(unconst_u32(99))][u32(unconst_u32(195))][0][0]));
  var vf110: mat4x3f = transpose(mat3x4f());
  vf110 = mat4x3f(f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]), f32(buffer203[u32(buffer203[u32(unconst_u32(9))][1][0][0])][u32(unconst_u32(75))][u32(unconst_u32(145))][0]));
  vf109 |= textureLoad(tex71, vec2i(i32((*&buffer203)[arrayLength(&(*&buffer203))][u32(unconst_u32(334))][0][0])), i32(unconst_i32(12))).ag;
  var vf111: vec2u = textureDimensions(tex70);
  let vf112: f32 = vf110[u32(unconst_u32(8))][textureNumLayers(tex70)];
  let ptr126: ptr<storage, f16, read> = &buffer203[arrayLength(&buffer203)][1][u32(unconst_u32(211))][u32(unconst_u32(71))];
  return out;
}

fn fn1() -> S6 {
  var out: S6;
  let ptr127: ptr<storage, f16, read> = &buffer203[arrayLength(&buffer203)][u32(unconst_u32(184))][bitcast<u32>(clamp(f32(unconst_f32(0.1525)), f32(unconst_f32(0.2362)), f32(unconst_f32(0.01967))))][u32(unconst_u32(80))];
  out.f0 = unpack4xU8(bitcast<u32>(countOneBits(i32(unconst_i32(181)))));
  out.f1 &= vec2i(i32((*&buffer203)[i32(unconst_i32(19))][1][0][0]));
  textureStore(st19, vec3i(unconst_i32(39), unconst_i32(45), unconst_i32(-78)), vec4f(vec4f(unconst_f32(0.04505), unconst_f32(-0.09599), unconst_f32(0.00510), unconst_f32(0.05411))));
  let ptr128: ptr<storage, array<f16, 1>, read> = &buffer203[arrayLength(&buffer203)][1][u32(unconst_u32(14))];
  let vf113: u32 = textureDimensions(tex69, 0i);
  out.f1 &= vec2i(bitcast<i32>(acos(f32(unconst_f32(0.2829)))));
  out.f0 += unpack4xU8(u32(buffer203[u32(unconst_u32(318))][1][0][0]));
  textureStore(st19, vec3i(unconst_i32(848), unconst_i32(13), unconst_i32(88)), vec4f(vec4f(unconst_f32(0.05242), unconst_f32(0.1893), unconst_f32(0.02430), unconst_f32(0.5447))));
  let ptr129: ptr<storage, f16, read> = &buffer203[arrayLength(&buffer203)][1][u32(unconst_u32(0))][u32(unconst_u32(202))];
  var vf114: vec4u = firstTrailingBit(vec4u(unconst_u32(44), unconst_u32(65), unconst_u32(134), unconst_u32(81)));
  textureStore(st19, vec3i(unconst_i32(467), unconst_i32(60), unconst_i32(181)), vec4f(vec4f(unconst_f32(-0.08525), unconst_f32(0.2030), unconst_f32(-0.03521), unconst_f32(0.04537))));
  vf114 >>= vec4u(u32((*&buffer203)[arrayLength(&(*&buffer203))][1][0][0]));
  return out;
}

@vertex
fn vertex10(@location(11) a0: i32, @location(0) a1: vec4u, @location(5) a2: vec2i, @location(9) @interpolate(flat) a3: i32, a4: S6) -> VertexOutput9 {
  var out: VertexOutput9;
  let ptr130: ptr<storage, array<array<f16, 1>, 1>, read> = &buffer203[u32(unconst_u32(258))][u32(unconst_u32(23))];
  out.f30 += unpack4x8snorm(dot(vec2u(log2(vec3h(unconst_f16(5530.4), unconst_f16(6951.9), unconst_f16(4195.5))).zx), vec2u(unconst_u32(82), unconst_u32(594))));
  out.f30 = vec4f(f32(buffer203[arrayLength(&buffer203)][1][0][0]));
  var vf115: vec4u = insertBits(vec4u(unconst_u32(200), unconst_u32(117), unconst_u32(57), unconst_u32(65)), vec4u(unconst_u32(24), unconst_u32(402), unconst_u32(25), unconst_u32(100)), u32(unconst_u32(112)), u32(unconst_u32(119)));
  var vf116: u32 = dot(vec2u(unconst_u32(270), unconst_u32(259)), vec2u(unconst_u32(261), unconst_u32(193)));
  let ptr131: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer203)[u32(unconst_u32(60))][u32(unconst_u32(5))];
  let ptr132: ptr<storage, f16, read> = &(*&buffer203)[arrayLength(&(*&buffer203))][u32(unconst_u32(46))][u32(unconst_u32(170))][0];
  let ptr133: ptr<storage, f16, read> = &buffer203[arrayLength(&buffer203)][1][0][u32(unconst_u32(366))];
  out.f30 -= vec4f(f32((*ptr130)[0][0]));
  let ptr134: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer203)[u32(unconst_u32(120))][u32(unconst_u32(388))];
  vf116 <<= u32((*ptr130)[0][u32(unconst_u32(64))]);
  out = VertexOutput9(vec4f(f32(buffer203[u32(unconst_u32(24))][u32(unconst_u32(645))][0][0])));
  vf116 <<= bitcast<u32>(a0);
  let ptr135: ptr<storage, f16, read> = &buffer203[arrayLength(&buffer203)][u32((*ptr134)[0][0])][0][0];
  let ptr136: ptr<storage, f16, read> = &(*ptr130)[u32((*ptr131)[0][0])][0];
  let ptr137: ptr<storage, f16, read> = &(*&buffer203)[arrayLength(&(*&buffer203))][1][u32(unconst_u32(197))][0];
  let ptr138: ptr<storage, array<array<array<f16, 1>, 1>, 2>, read> = &(*&buffer203)[i32(unconst_i32(59))];
  return out;
}

@vertex
fn vertex11(@location(11) a0: vec2h, @location(4) @interpolate(flat) a1: vec4i) -> VertexOutput10 {
  var out: VertexOutput10;
  out.f31 = vec4h((*&buffer203)[u32(unconst_u32(157))][u32(unconst_u32(123))][0][u32(unconst_u32(186))]);
  out.f31 = vec4h(buffer203[arrayLength(&buffer203)][1][0][0]);
  out.f31 = vec4h((*&buffer203)[arrayLength(&(*&buffer203))][u32(unconst_u32(5))][0][u32(unconst_u32(54))]);
  let ptr139: ptr<storage, f16, read> = &(*&buffer203)[arrayLength(&(*&buffer203))][u32(unconst_u32(53))][0][u32(unconst_u32(334))];
  var vf117: vec3u = textureDimensions(st20);
  var vf118: vec2h = a0;
  return out;
}

@fragment
fn fragment6(@location(8) a0: vec2u, @location(12) a1: vec4u) -> FragmentOutput4 {
  var out: FragmentOutput4;
  fn0();
  textureStore(st19, vec3i(unconst_i32(518), unconst_i32(93), unconst_i32(281)), vec4f(vec4f(unconst_f32(0.2021), unconst_f32(0.08112), unconst_f32(0.4345), unconst_f32(0.2721))));
  let ptr140: ptr<storage, f16, read> = &(*&buffer203)[arrayLength(&(*&buffer203))][1][u32(unconst_u32(272))][0];
  fn1();
  let ptr141: ptr<storage, f16, read> = &buffer203[arrayLength(&buffer203)][1][u32(unconst_u32(55))][u32(unconst_u32(34))];
  var vf119: u32 = (*&buffer202)[u32(unconst_u32(68))];
  let ptr142: ptr<storage, array<array<f16, 1>, 1>, read> = &buffer203[u32(log2(vec3f(unconst_f32(-0.04340), unconst_f32(0.04314), unconst_f32(-0.2849)))[0])][u32(unconst_u32(52))];
  var vf120 = fn1();
  vf120 = S6(unpack4xU8(u32(buffer203[arrayLength(&buffer203)][u32(unconst_u32(24))][0][0])), vec2i(i32(buffer203[arrayLength(&buffer203)][u32(unconst_u32(24))][0][0])), buffer203[arrayLength(&buffer203)][u32(unconst_u32(24))][0][0]);
  var vf121 = fn0();
  let ptr143: ptr<function, vec4i> = &vf121;
  let ptr144: ptr<storage, f16, read> = &(*ptr142)[0][u32(unconst_u32(22))];
  fn0();
  out.f1 |= vec2i(i32((*&buffer203)[arrayLength(&(*&buffer203))][1][u32(unconst_u32(42))][0]));
  return out;
}

@compute @workgroup_size(2, 2, 1)
fn compute8() {
  fn1();
  textureStore(st19, vec3i(unconst_i32(50), unconst_i32(165), unconst_i32(28)), vec4f(vec4f(unconst_f32(0.1027), unconst_f32(0.01371), unconst_f32(0.08972), unconst_f32(0.2422))));
  textureStore(st19, vec3i(unconst_i32(129), unconst_i32(14), unconst_i32(20)), vec4f(vec4f(unconst_f32(0.3341), unconst_f32(0.01075), unconst_f32(-0.1232), unconst_f32(0.04829))));
  textureStore(st19, vec3i(unconst_i32(249), unconst_i32(370), unconst_i32(86)), vec4f(vec4f(unconst_f32(0.03144), unconst_f32(0.3931), unconst_f32(0.1993), unconst_f32(0.2989))));
  var vf122 = fn1();
  vf122.f1 ^= vec2i(i32((*&buffer203)[arrayLength(&(*&buffer203))][u32(unconst_u32(620))][u32(unconst_u32(252))][0]));
  vf122 = S6(vec4u(textureNumLevels(tex70)), vec2i(bitcast<i32>(textureNumLevels(tex70))), f16(textureNumLevels(tex70)));
  fn1();
  fn1();
  var vf123: u32 = buffer202[u32(unconst_u32(313))];
  textureStore(st19, vec3i(unconst_i32(202), unconst_i32(246), unconst_i32(5)), vec4f(vec4f(unconst_f32(0.1966), unconst_f32(0.1105), unconst_f32(0.06219), unconst_f32(0.6542))));
  var vf124: u32 = pack4x8unorm(radians(vec3f(unconst_f32(0.04149), unconst_f32(0.4037), unconst_f32(0.1441))).grrg);
  let ptr145: ptr<uniform, vec2u> = &buffer202;
  var vf125 = fn1();
  vf125 = S6(vec4u(textureDimensions(tex69)), vec2i(i32(textureDimensions(tex69))), f16(textureDimensions(tex69)));
  fn1();
  vf124 <<= u32(vf125.f1[u32(unconst_u32(221))]);
  let ptr146: ptr<storage, f16, read> = &buffer203[u32(unconst_u32(174))][1][0][0];
  textureStore(st19, vec3i(unconst_i32(146), unconst_i32(312), unconst_i32(10)), vec4f(vec4f(unconst_f32(0.04602), unconst_f32(0.3176), unconst_f32(0.4424), unconst_f32(0.1332))));
  var vf126 = fn1();
  var vf127: vec4f = faceForward(vec4f(unconst_f32(0.08826), unconst_f32(0.3936), unconst_f32(0.7233), unconst_f32(0.1929)), vec4f(unconst_f32(0.5844), unconst_f32(0.2218), unconst_f32(0.00416), unconst_f32(0.00576)), vec4f(unconst_f32(0.00857), unconst_f32(0.2876), unconst_f32(0.1039), unconst_f32(-0.3773)));
}`,
  sourceMap: {},
  hints: {},
});
let buffer204 = device0.createBuffer({
  size: 1006,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView293 = texture90.createView({dimension: '2d', baseArrayLayer: 1});
let computePassEncoder214 = commandEncoder254.beginComputePass({label: '\u3989\u2326\u0d02'});
try {
computePassEncoder48.setBindGroup(1, bindGroup59);
} catch {}
try {
computePassEncoder39.setBindGroup(1, bindGroup63, new Uint32Array(3027), 426, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle28, renderBundle28, renderBundle17, renderBundle0, renderBundle1]);
} catch {}
try {
renderPassEncoder47.setBlendConstant({ r: -281.2, g: -243.2, b: 68.25, a: 152.8, });
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let videoFrame42 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte432', transfer: 'unspecified'} });
let bindGroup151 = device0.createBindGroup({
  label: '\u{1fc71}\u0d07\u{1fd35}\u0842\u6845',
  layout: bindGroupLayout15,
  entries: [{binding: 61, resource: textureView126}],
});
let texture286 = device0.createTexture({
  size: {width: 1290},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView294 = texture151.createView({mipLevelCount: 1, arrayLayerCount: 4});
let renderPassEncoder50 = commandEncoder257.beginRenderPass({colorAttachments: [{view: textureView221, loadOp: 'clear', storeOp: 'store'}]});
let renderBundleEncoder38 = device0.createRenderBundleEncoder({label: '\u93bf\u25c6\u5800\u{1ff7f}\u0273\uf47e\u{1feaf}\u219a', colorFormats: ['rg8uint']});
try {
{ clearResourceUsages(device0, computePassEncoder42); computePassEncoder42.dispatchWorkgroupsIndirect(buffer176, 1_172); };
} catch {}
try {
computePassEncoder170.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder197.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder23.setBlendConstant({ r: -757.5, g: 669.8, b: 112.6, a: 842.4, });
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer20, 0, 623);
} catch {}
try {
renderBundleEncoder38.setBindGroup(3, bindGroup144);
} catch {}
try {
renderBundleEncoder38.setBindGroup(1, bindGroup50, new Uint32Array(1834), 147, 0);
} catch {}
try {
renderBundleEncoder38.setPipeline(pipeline3);
} catch {}
try {
commandEncoder252.copyTextureToBuffer({
  texture: texture73,
  mipLevel: 0,
  origin: {x: 4, y: 7, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 208 */
  offset: 208,
  rowsPerImage: 269,
  buffer: buffer60,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder252.copyTextureToTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 62, y: 0, z: 42},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 6},
  aspect: 'all',
},
{width: 27, height: 2, depthOrArrayLayers: 4});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer205 = device0.createBuffer({
  size: 2979,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder258 = device0.createCommandEncoder();
try {
computePassEncoder109.setBindGroup(2, bindGroup114, new Uint32Array(7232), 2_730, 0);
} catch {}
try {
computePassEncoder205.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer148, 'uint16', 144, 2_958);
} catch {}
try {
renderBundleEncoder38.setIndexBuffer(buffer36, 'uint16', 118, 6_965);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1290, height: 8, depthOrArrayLayers: 10}
*/
{
  source: imageData25,
  origin: { x: 2, y: 1 },
  flipY: false,
}, {
  texture: texture215,
  mipLevel: 0,
  origin: {x: 8, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext12 = offscreenCanvas7.getContext('webgpu');
let texture287 = device0.createTexture({
  size: {width: 322},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture288 = device0.createTexture({
  label: '\u407a\u{1f861}\u5451\u{1f76c}\u48ed\u0839\ud8d5\uf9d0\u{1fbc5}',
  size: {width: 161, height: 1, depthOrArrayLayers: 15},
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder5.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder52.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer79, 'uint16', 1_692, 1_605);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer158, 0, 725);
} catch {}
try {
renderBundleEncoder38.setBindGroup(2, bindGroup77);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder258.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 68 */
  offset: 68,
  bytesPerRow: 5888,
  rowsPerImage: 1092,
  buffer: buffer54,
}, {
  texture: texture287,
  mipLevel: 0,
  origin: {x: 211, y: 0, z: 0},
  aspect: 'all',
}, {width: 40, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer158, 1912, new BigUint64Array(13317), 1429, 56);
} catch {}
document.body.append(img1);
let commandEncoder259 = device0.createCommandEncoder();
let texture289 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder215 = commandEncoder258.beginComputePass();
let renderBundle38 = renderBundleEncoder38.finish({});
let externalTexture33 = device0.importExternalTexture({source: videoFrame9});
try {
renderPassEncoder15.setBindGroup(3, bindGroup144);
} catch {}
try {
renderPassEncoder30.setBlendConstant({ r: 271.7, g: -83.54, b: 278.4, a: 454.8, });
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer206 = device0.createBuffer({
  size: 3704,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture290 = device0.createTexture({
  label: '\u{1fbbf}\u6263\u{1fac8}\u7c30\uf9af\u{1fe6c}\u3447',
  size: [2],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder84.setBindGroup(0, bindGroup34, new Uint32Array(1243), 465, 0);
} catch {}
try {
computePassEncoder72.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup86, new Uint32Array(1641), 417, 0);
} catch {}
try {
commandEncoder252.copyBufferToBuffer(buffer56, 876, buffer60, 4, 88);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame16,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture164,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup152 = device0.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 30, resource: textureView1}]});
let buffer207 = device0.createBuffer({
  size: 808,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
renderPassEncoder20.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer78, 'uint32', 3_808, 939);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(5, buffer206);
} catch {}
let texture291 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 8},
  sampleCount: 1,
  dimension: '2d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder216 = commandEncoder252.beginComputePass();
try {
computePassEncoder193.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup124);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer164);
} catch {}
try {
commandEncoder259.resolveQuerySet(querySet18, 20, 70, buffer150, 256);
} catch {}
let computePassEncoder217 = commandEncoder259.beginComputePass({});
try {
computePassEncoder145.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder172.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup100, new Uint32Array(211), 8, 0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle28, renderBundle28]);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(7, buffer38, 140, 320);
} catch {}
try {
computePassEncoder132.insertDebugMarker('\ua8aa');
} catch {}
try {
renderPassEncoder48.insertDebugMarker('\u{1f7f1}');
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let bindGroup153 = device0.createBindGroup({
  label: '\u0d87\u5a0c\u52a7\u8d4f\u253b\u0cc8\ud906\ufd96\u0bc3',
  layout: bindGroupLayout31,
  entries: [{binding: 44, resource: {buffer: buffer172, offset: 2816, size: 7891}}],
});
let buffer208 = device0.createBuffer({size: 5155, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
try {
renderPassEncoder48.setBindGroup(0, bindGroup51);
} catch {}
try {
renderPassEncoder48.setBindGroup(2, bindGroup36, new Uint32Array(552), 15, 0);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(82);
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
try {
  await promise27;
} catch {}
document.body.prepend(canvas0);
let buffer209 = device0.createBuffer({
  size: 4683,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture292 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 31},
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView295 = texture285.createView({baseMipLevel: 0});
let sampler147 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 54.02,
  lodMaxClamp: 96.51,
  maxAnisotropy: 8,
});
try {
computePassEncoder205.setBindGroup(2, bindGroup64, new Uint32Array(2906), 218, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer30, 'uint32', 300, 548);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
document.body.prepend(canvas2);
let offscreenCanvas8 = new OffscreenCanvas(1, 70);
try {
renderPassEncoder17.setBindGroup(3, bindGroup41, new Uint32Array(12), 0, 0);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline3);
} catch {}
let arrayBuffer21 = buffer0.getMappedRange(72, 0);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 27}
*/
{
  source: imageData8,
  origin: { x: 6, y: 5 },
  flipY: false,
}, {
  texture: texture205,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup154 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer89, offset: 2816, size: 8316}},
    {binding: 37, resource: textureView47},
  ],
});
let renderBundleEncoder39 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: false});
try {
computePassEncoder85.setBindGroup(0, bindGroup150, new Uint32Array(1954), 338, 0);
} catch {}
try {
computePassEncoder179.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup19, new Uint32Array(1553), 58, 0);
} catch {}
try {
renderPassEncoder12.setScissorRect(25, 9, 2, 5);
} catch {}
try {
renderPassEncoder10.setStencilReference(980);
} catch {}
try {
computePassEncoder65.insertDebugMarker('\u4026');
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
let textureView296 = texture148.createView({dimension: '2d', format: 'rgb10a2uint', baseArrayLayer: 29});
let renderBundle39 = renderBundleEncoder39.finish({});
try {
computePassEncoder32.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer145, 'uint16', 3_148, 1_128);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
  await promise28;
} catch {}
let videoFrame43 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'gamma22curve'} });
let buffer210 = device0.createBuffer({
  size: 11314,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture293 = device0.createTexture({
  label: '\u{1fd3e}\u46f9\u85de\u27dd\u0018\u{1f651}\u0a86\uda42\uf866',
  size: [26],
  sampleCount: 1,
  dimension: '1d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST,
});
let sampler148 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 77.75,
  lodMaxClamp: 78.01,
  compare: 'greater',
});
let texture294 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 31},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder215.setBindGroup(1, bindGroup115);
} catch {}
try {
computePassEncoder42.end();
} catch {}
let pipeline5 = device0.createComputePipeline({layout: pipelineLayout6, compute: {module: shaderModule1, constants: {}}});
let gpuCanvasContext13 = offscreenCanvas8.getContext('webgpu');
try {
device0.label = '\u1ca6\u85c5\u05d5\u00ea\u1192\u8d1e\ud2a7\u{1f799}';
} catch {}
let commandBuffer4 = commandEncoder50.finish();
let sampler149 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 92.78,
  lodMaxClamp: 98.93,
});
try {
renderPassEncoder9.setIndexBuffer(buffer8, 'uint32', 7_968, 3_094);
} catch {}
let promise29 = device0.queue.onSubmittedWorkDone();
try {
{ clearResourceUsages(device0, computePassEncoder124); computePassEncoder124.dispatchWorkgroupsIndirect(buffer139, 752); };
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup87);
} catch {}
let imageData35 = new ImageData(4, 56);
let renderBundleEncoder40 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder120.setBindGroup(1, bindGroup118);
} catch {}
try {
computePassEncoder95.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup20, new Uint32Array(3565), 349, 0);
} catch {}
try {
renderPassEncoder49.setIndexBuffer(buffer17, 'uint16', 1_022, 530);
} catch {}
try {
renderBundleEncoder40.setIndexBuffer(buffer87, 'uint32', 12, 799);
} catch {}
try {
renderBundleEncoder40.setPipeline(pipeline3);
} catch {}
await gc();
let bindGroup155 = device0.createBindGroup({
  label: '\u04e0\u00fb\u05a6\u22c4',
  layout: bindGroupLayout8,
  entries: [{binding: 31, resource: textureView234}],
});
let textureView297 = texture269.createView({dimension: '3d', baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder18.setBindGroup(2, bindGroup50);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(1, buffer22, 584);
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 56, new Int16Array(3113), 545, 140);
} catch {}
let buffer211 = device0.createBuffer({size: 2196, usage: GPUBufferUsage.MAP_READ});
let texture295 = device0.createTexture({
  size: [161, 1, 15],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView298 = texture55.createView({dimension: '2d', mipLevelCount: 1});
try {
computePassEncoder25.setBindGroup(3, bindGroup74, new Uint32Array(1955), 143, 0);
} catch {}
try {
renderBundleEncoder40.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroupLayout35 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 681,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer212 = device0.createBuffer({size: 9015, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder260 = device0.createCommandEncoder({});
let textureView299 = texture12.createView({});
let computePassEncoder218 = commandEncoder260.beginComputePass({label: '\u{1f617}\uac5f\u{1fecf}\ucce5\u2df4\u9407\u{1f886}\udcef\u89f6\uf9d4\uef02'});
let renderBundle40 = renderBundleEncoder40.finish({label: '\u0182\u{1fc53}\uf8e0\ufd83\uf751\u067a\u0949'});
try {
computePassEncoder180.insertDebugMarker('\u0cf0');
} catch {}
let bindGroup156 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 134, resource: textureView72},
    {binding: 8, resource: {buffer: buffer83, offset: 256}},
    {binding: 72, resource: {buffer: buffer95, offset: 11776, size: 236}},
    {binding: 58, resource: textureView266},
    {binding: 66, resource: textureView187},
    {binding: 495, resource: {buffer: buffer62, offset: 7168}},
    {binding: 207, resource: textureView123},
    {binding: 108, resource: {buffer: buffer204, offset: 256, size: 179}},
    {binding: 268, resource: textureView128},
    {binding: 319, resource: externalTexture32},
    {binding: 25, resource: {buffer: buffer12, offset: 3840, size: 3101}},
    {binding: 0, resource: textureView177},
    {binding: 156, resource: textureView276},
    {binding: 189, resource: textureView82},
  ],
});
let querySet36 = device0.createQuerySet({type: 'occlusion', count: 352});
let texture296 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 625},
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder21.setBindGroup(1, bindGroup153);
} catch {}
try {
computePassEncoder26.setBindGroup(2, bindGroup150, new Uint32Array(367), 41, 0);
} catch {}
try {
computePassEncoder215.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle31]);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder121.pushDebugGroup('\u3cc4');
} catch {}
try {
computePassEncoder121.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture116,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(112).fill(119), /* required buffer size: 112 */
{offset: 112}, {width: 7, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 20, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture284,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView300 = texture56.createView({baseArrayLayer: 13, arrayLayerCount: 10});
try {
computePassEncoder161.setBindGroup(0, bindGroup149, new Uint32Array(582), 2, 0);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup78);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer79, 'uint16', 208, 322);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 55, height: 8, depthOrArrayLayers: 312}
*/
{
  source: imageData32,
  origin: { x: 14, y: 2 },
  flipY: false,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 89},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 14, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder124); computePassEncoder124.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder149.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder29.setBlendConstant({ r: -46.15, g: 842.6, b: -281.7, a: 821.7, });
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let bindGroupLayout36 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 35,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 140,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 869, hasDynamicOffset: true },
    },
    {
      binding: 105,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 170,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 50,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let bindGroup157 = device0.createBindGroup({
  label: '\u0c51\u{1fc78}\u0d06\uec29\ufe45\u396e\u0a9f\u13e5\ub43a\u{1ff87}\u0855',
  layout: bindGroupLayout1,
  entries: [],
});
let texture297 = device0.createTexture({
  size: [13],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture298 = device0.createTexture({
  label: '\u{1facc}\u{1fb82}\u0d49\u{1fb1b}\u{1f9ae}\ue891',
  size: {width: 2376, height: 240, depthOrArrayLayers: 1},
  format: 'astc-12x12-unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder200.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder44.setIndexBuffer(buffer136, 'uint16', 10_700, 409);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, undefined, 0, 52_399_411);
} catch {}
let textureView301 = texture210.createView({label: '\u0036\u{1f6df}\ufab5\u{1f7ba}\u69c6', dimension: 'cube-array', arrayLayerCount: 12});
let sampler150 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 54.56,
  lodMaxClamp: 97.27,
});
try {
computePassEncoder56.setBindGroup(3, bindGroup8, new Uint32Array(1206), 304, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer157, 'uint32', 1_732, 96);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline6 = device0.createRenderPipeline({
  layout: pipelineLayout9,
  multisample: {count: 4, mask: 0x4dae2ee3},
  fragment: {
  module: shaderModule5,
  constants: {},
  targets: [{format: 'rg16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.GREEN,
}, {format: 'rgba16uint'}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'rgba16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE,
}, {
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'one-minus-constant'},
  },
  writeMask: 0,
}],
},
  vertex: {
    module: shaderModule5,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 4, shaderLocation: 2},
          {format: 'snorm8x2', offset: 302, shaderLocation: 11},
          {format: 'uint8x4', offset: 60, shaderLocation: 5},
          {format: 'uint16x4', offset: 40, shaderLocation: 14},
          {format: 'uint8x2', offset: 284, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
let texture299 = device0.createTexture({
  label: '\u4244\u2df1\uacdf\u0785\u74f7\u0e45\u4beb',
  size: {width: 110},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler151 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 96.83,
  lodMaxClamp: 98.33,
  maxAnisotropy: 1,
});
let externalTexture34 = device0.importExternalTexture({source: videoFrame37});
try {
computePassEncoder18.setBindGroup(1, bindGroup74);
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup52);
} catch {}
try {
renderPassEncoder43.setBindGroup(0, bindGroup76, new Uint32Array(637), 31, 0);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(1, buffer20, 1_840);
} catch {}
let shaderModule9 = device0.createShaderModule({
  label: '\u803c\u9184\ubebe',
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer213: vec2u;

@group(0) @binding(38) var st21: texture_storage_3d<rg32float, write>;

@group(0) @binding(41) var<storage, read> buffer214: u32;

@group(0) @binding(107) var tex72: texture_1d<u32>;

@group(0) @binding(115) var tex73: texture_1d<i32>;

@group(0) @binding(268) var tex74: texture_2d_array<u32>;

@group(0) @binding(296) var tex75: texture_2d<u32>;

struct T0 {
  f0: vec2f,
}

struct T1 {
  @size(700) f0: array<u32>,
}

struct VertexOutput11 {
  @builtin(position) f34: vec4f,
}

struct S7 {
  @builtin(sample_index) f0: u32,
}

struct FragmentOutput5 {
  @location(0) f0: vec2f,
  @location(1) @interpolate(flat, sample) f1: vec4i,
  @builtin(sample_mask) f2: u32,
  @location(3) @interpolate(perspective, sample) f3: vec2f,
}

alias vec3b = vec3<bool>;

fn fn0(a0: ptr<function, S7>) -> S7 {
  var out: S7;
  vp5[u32(unconst_u32(58))].whole -= f16((*&vw27).f0.g);
  let vf128: vec2u = textureDimensions(tex74);
  let vf129: u32 = vf128[u32(unconst_u32(927))];
  var vf130: array<S7, 3> = workgroupUniformLoad(&vw28);
  let ptr147: ptr<private, f16> = &vp5[7].fract;
  let ptr148: ptr<workgroup, vec2f> = &vw27.f3;
  textureStore(st21, vec3i(unconst_i32(29), unconst_i32(60), unconst_i32(483)), vec4f(vec4f(bitcast<f32>(vw28[u32(unconst_u32(45))].f0))));
  let ptr149: ptr<workgroup, u32> = &vw28[u32(unconst_u32(81))].f0;
  textureStore(st21, vec3i(textureLoad(tex74, vec2i(unconst_i32(567), unconst_i32(28)), i32(unconst_i32(120)), bitcast<i32>(vw28[u32(unconst_u32(35))].f0)).rgr), vec4f(vec4f(unconst_f32(-0.1972), unconst_f32(0.04142), unconst_f32(0.2652), unconst_f32(0.5973))));
  textureStore(st21, vec3i(unconst_i32(46), unconst_i32(4), unconst_i32(-361)), vec4f(vec4f(unconst_f32(0.02543), unconst_f32(0.3341), unconst_f32(0.1510), unconst_f32(0.1143))));
  let ptr150: ptr<workgroup, S7> = &vw28[2];
  let ptr151: ptr<workgroup, vec2f> = &vw27.f3;
  let vf131: i32 = (*&vw27).f1[u32(unconst_u32(35))];
  let vf132: vec2h = sign(vec2h(unconst_f16(27661.8), unconst_f16(3472.2)));
  let ptr152: ptr<function, S7> = &vf130[u32(unconst_u32(147))];
  vw27 = FragmentOutput5(vec2f(bitcast<f32>((*ptr150).f0)), vec4i(i32((*ptr150).f0)), (*ptr150).f0, vec2f(f32((*ptr150).f0)));
  let ptr153: ptr<workgroup, vec2f> = &(*&vw27).f3;
  var vf133: vec2h = sign(vec2h(unconst_f16(1750.6), unconst_f16(3027.8)));
  let ptr154: ptr<workgroup, FragmentOutput5> = &(*&vw27);
  let ptr155: ptr<workgroup, vec4i> = &vw27.f1;
  var vf134: vec2u = textureDimensions(tex74, i32(unconst_i32(122)));
  let ptr156: ptr<function, u32> = &(*ptr152).f0;
  let ptr157: ptr<workgroup, vec2f> = &(*ptr151);
  return out;
}

fn fn1() -> bool {
  var out: bool;
  vw27 = FragmentOutput5(vec2f(f32(vp5[u32(unconst_u32(16))].whole)), vec4i(i32(vp5[u32(unconst_u32(16))].whole)), u32(vp5[u32(unconst_u32(16))].whole), vec2f(f32(vp5[u32(unconst_u32(16))].whole)));
  let ptr158: ptr<storage, u32, read> = &(*&buffer214);
  textureStore(st21, vec3i(unconst_i32(54), unconst_i32(-307), unconst_i32(133)), vec4f(vec4f(unconst_f32(0.3139), unconst_f32(0.01643), unconst_f32(0.07577), unconst_f32(0.3578))));
  var vf135: u32 = pack4x8unorm(vec4f(unconst_f32(0.09723), unconst_f32(0.4971), unconst_f32(0.1467), unconst_f32(0.05132)));
  let ptr159: ptr<workgroup, vec2f> = &vw27.f3;
  var vf136: f32 = cos(f32(unconst_f32(0.03369)));
  let ptr160: ptr<workgroup, u32> = &vw27.f2;
  let ptr161: ptr<workgroup, FragmentOutput5> = &(*&vw27);
  textureStore(st21, vec3i(unconst_i32(23), unconst_i32(474), unconst_i32(313)), vec4f(vec4f(unconst_f32(1.000), unconst_f32(0.1437), unconst_f32(0.2234), unconst_f32(0.2627))));
  textureStore(st21, vec3i(unconst_i32(57), unconst_i32(271), unconst_i32(1)), vec4f(vec4f(unconst_f32(0.1230), unconst_f32(0.2611), unconst_f32(0.1231), unconst_f32(0.2147))));
  let ptr162: ptr<workgroup, S7> = &(*&vw28)[u32(unconst_u32(113))];
  vw28[2] = (*&vw28)[2];
  vw28[u32(unconst_u32(45))].f0 *= u32(vp5[u32(unconst_u32(75))].whole);
  vw28[u32(unconst_u32(120))] = S7(vw27.f2);
  return out;
}

fn fn2(a0: mat4x2h) -> mat3x3h {
  var out: mat3x3h;
  let ptr163 = &vp5[7];
  let ptr164 = &(*ptr163);
  let vf137: vec2h = a0[vec3u(atan(vec3f(unconst_f32(0.02291), unconst_f32(0.02920), unconst_f32(-0.1837))))[1]];
  let ptr165 = &vp5;
  out = mat3x3h((*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole, (*ptr165)[u32(unconst_u32(19))].whole);
  vp5[u32(unconst_u32(44))].whole = vp5[7].whole;
  let ptr166: ptr<private, f16> = &(*ptr165)[7].whole;
  let ptr167: ptr<private, f16> = &(*ptr164).fract;
  let ptr168: ptr<private, f16> = &(*ptr165)[7].fract;
  let ptr169: ptr<private, f16> = &(*ptr164).fract;
  out = mat3x3h((*ptr168), (*ptr168), (*ptr168), (*ptr168), (*ptr168), (*ptr168), (*ptr168), (*ptr168), (*ptr168));
  let ptr170: ptr<private, f16> = &(*ptr165)[u32(unconst_u32(7))].fract;
  let ptr171: ptr<private, f16> = &(*ptr164).fract;
  let ptr172: ptr<private, f16> = &vp5[u32((*ptr165)[7].whole)].fract;
  let ptr173 = &(*ptr163);
  return out;
}

var<workgroup> vw27: FragmentOutput5;

var<workgroup> vw28: array<S7, 3>;

var<private> vp5 = array(modf(f16(5992.2)), modf(f16(27711.5)), modf(f16(12610.1)), modf(f16(1592.6)), modf(f16(14503.3)), modf(f16(477.8)), modf(f16(19815.8)), modf(f16(19332.2)));

@vertex
fn vertex12() -> VertexOutput11 {
  var out: VertexOutput11;
  let vf138: mat4x2h = transpose(mat2x4h());
  let vf139: vec2f = unpack2x16float(u32(unconst_u32(294)));
  var vf140: f32 = vf139[u32(unconst_u32(39))];
  vf140 *= bitcast<f32>(vf138[u32(unconst_u32(338))]);
  fn2(mat4x2h(unconst_f16(1993.6), unconst_f16(8846.4), unconst_f16(329.5), unconst_f16(4769.7), unconst_f16(4683.4), unconst_f16(355.6), unconst_f16(-13855.2), unconst_f16(10373.6)));
  out.f34 = unpack4x8unorm((*&buffer214));
  vp5[7].fract -= f16((*&buffer214));
  out = VertexOutput11(vec4f(vf138[unconst_i32(0)].grgg));
  vf140 = f32(vp5[u32(unconst_u32(51))].fract);
  var vf141 = fn2(mat4x2h(f16(buffer214), f16(buffer214), f16(buffer214), f16(buffer214), f16(buffer214), f16(buffer214), f16(buffer214), f16(buffer214)));
  vp5[u32(unconst_u32(110))].fract = vf138[u32(unconst_u32(75))][0];
  out = VertexOutput11(vec4f(f32(vp5[7].whole)));
  var vf142 = fn2(mat4x2h(f16(vf139[u32(unconst_u32(323))]), f16(vf139[u32(unconst_u32(323))]), f16(vf139[u32(unconst_u32(323))]), f16(vf139[u32(unconst_u32(323))]), f16(vf139[u32(unconst_u32(323))]), f16(vf139[u32(unconst_u32(323))]), f16(vf139[u32(unconst_u32(323))]), f16(vf139[u32(unconst_u32(323))])));
  let ptr174 = &vp5;
  fn2(mat4x2h(vp5[u32(unconst_u32(349))].whole, vp5[u32(unconst_u32(349))].whole, vp5[u32(unconst_u32(349))].whole, vp5[u32(unconst_u32(349))].whole, vp5[u32(unconst_u32(349))].whole, vp5[u32(unconst_u32(349))].whole, vp5[u32(unconst_u32(349))].whole, vp5[u32(unconst_u32(349))].whole));
  var vf143: mat4x2h = vf138;
  out = VertexOutput11(vec4f(vf138[unconst_i32(0)].yyxy));
  fn2(mat4x2h());
  var vf144 = fn2(mat4x2h(unconst_f16(5817.2), unconst_f16(12558.4), unconst_f16(27398.3), unconst_f16(16183.4), unconst_f16(11120.4), unconst_f16(13388.0), unconst_f16(21683.2), unconst_f16(17207.3)));
  let ptr175 = &vp5[7];
  return out;
}

@fragment
fn fragment7(@builtin(front_facing) a0: bool, a1: S7) -> FragmentOutput5 {
  var out: FragmentOutput5;
  out.f3 -= vec2f(radians(vec3h(unconst_f16(3938.9), unconst_f16(2310.2), unconst_f16(4977.7))).zz);
  fn2(mat4x2h(f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663)))), f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663)))), f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663)))), f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663)))), f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663)))), f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663)))), f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663)))), f16(distance(vec4f(unconst_f32(0.1011), unconst_f32(0.2929), unconst_f32(0.01671), unconst_f32(0.1929)), vec4f(unconst_f32(0.1413), unconst_f32(0.06721), unconst_f32(0.1319), unconst_f32(0.2663))))));
  let ptr176: ptr<uniform, vec2u> = &(*&buffer213);
  out.f1 = vec4i(i32(vp5[u32(unconst_u32(15))].whole));
  out.f1 = bitcast<vec4i>(textureDimensions(tex75).yyxx);
  vp5[u32(unconst_u32(161))] = modf(f16(textureDimensions(tex72)));
  vp5[u32(unconst_u32(161))] = modf(f16(a1.f0));
  fn2(mat4x2h(f16(reverseBits(u32(unconst_u32(118)))), f16(reverseBits(u32(unconst_u32(118)))), f16(reverseBits(u32(unconst_u32(118)))), f16(reverseBits(u32(unconst_u32(118)))), f16(reverseBits(u32(unconst_u32(118)))), f16(reverseBits(u32(unconst_u32(118)))), f16(reverseBits(u32(unconst_u32(118)))), f16(reverseBits(u32(unconst_u32(118))))));
  let ptr177 = &vp5[textureDimensions(tex75)[1]];
  let ptr178: ptr<uniform, vec2u> = &buffer213;
  let ptr179: ptr<private, f16> = &vp5[7].fract;
  out.f0 = vec2f(radians(vec3h(unconst_f16(24405.8), unconst_f16(5793.4), unconst_f16(32219.2))).rr);
  fn2(mat4x2h(f16(a0), f16(a0), f16(a0), f16(a0), f16(a0), f16(a0), f16(a0), f16(a0)));
  fn2(mat4x2h());
  out.f2 >>= a1.f0;
  textureStore(st21, vec3i(bitcast<i32>(countLeadingZeros(u32(unconst_u32(6))))), vec4f(unpack4x8unorm(pack2x16float(vec2f(unconst_f32(0.1489), unconst_f32(0.1405))))));
  var vf145: vec2u = textureDimensions(tex75);
  fn2(mat4x2h(f16(textureDimensions(tex73, 0i)), f16(textureDimensions(tex73, 0i)), f16(textureDimensions(tex73, 0i)), f16(textureDimensions(tex73, 0i)), f16(textureDimensions(tex73, 0i)), f16(textureDimensions(tex73, 0i)), f16(textureDimensions(tex73, 0i)), f16(textureDimensions(tex73, 0i))));
  out.f3 += vec2f(bitcast<f32>(textureNumLayers(tex74)));
  var vf146 = fn2(mat4x2h(f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73)))), f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73)))), f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73)))), f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73)))), f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73)))), f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73)))), f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73)))), f16(pack2x16snorm(unpack2x16float(textureNumLevels(tex73))))));
  return out;
}

@compute @workgroup_size(3, 2, 1)
fn compute9() {
  vw27.f1 = bitcast<vec4i>(unpack4xU8(pack4xU8(bitcast<vec4u>((*&vw27).f1))));
  vp5[u32(unconst_u32(33))].whole -= f16((*&vw28)[u32(unconst_u32(137))].f0);
  textureStore(st21, vec3i(unconst_i32(351), unconst_i32(510), unconst_i32(66)), vec4f((*&vw27).f0.xyyy));
  let vf147: u32 = (*&buffer213)[u32(unconst_u32(63))];
  textureBarrier();
  fn1();
  let ptr180: ptr<workgroup, u32> = &(*&vw27).f2;
  let vf148: f32 = atanh(f32(unconst_f32(0.1518)));
  textureStore(st21, vec3i(unconst_i32(62), unconst_i32(275), unconst_i32(-33)), vec4f(vec4f(unconst_f32(0.2474), unconst_f32(0.05017), unconst_f32(0.2684), unconst_f32(0.2216))));
  vp5[u32(unconst_u32(122))].fract = f16((*&vw28)[u32(unconst_u32(59))].f0);
  let vf149: FragmentOutput5 = workgroupUniformLoad(&vw27);
  vw28[u32(unconst_u32(255))].f0 |= vw28[2].f0;
  textureStore(st21, vec3i(unconst_i32(318), unconst_i32(24), unconst_i32(33)), vec4f(vec4f(unconst_f32(-0.4412), unconst_f32(0.3870), unconst_f32(0.1366), unconst_f32(0.1228))));
  var vf150: vec2h = select(vec2h(unconst_f16(8032.0), unconst_f16(934.9)), vec2h(unconst_f16(17250.7), unconst_f16(20115.7)), bool(unconst_bool(true)));
}`,
  sourceMap: {},
  hints: {},
});
let buffer215 = device0.createBuffer({size: 418, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView302 = texture297.createView({label: '\ucee1\u{1fde7}\uab9b\ufae0\u8775\u7bc4\u04aa\ucdbf\u{1f64a}\u54c7', arrayLayerCount: 1});
let textureView303 = texture113.createView({label: '\u{1fd19}\u{1fe9a}\ucdbc\u1c80\u97ea\u{1f7ad}\u4f49\u2de2\u{1fb12}\u{1f7c3}\u317d'});
let sampler152 = device0.createSampler({
  label: '\uc646\u{1f6ef}\u{1fc3d}\u00e0\u0445',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 98.66,
});
try {
computePassEncoder124.end();
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup69);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder17.setScissorRect(13, 16, 9, 0);
} catch {}
let arrayBuffer22 = buffer71.getMappedRange(40, 0);
try {
commandEncoder147.copyTextureToTexture({
  texture: texture136,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture289,
  mipLevel: 0,
  origin: {x: 4, y: 5, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder147.clearBuffer(buffer28, 784, 312);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup158 = device0.createBindGroup({
  label: '\u0668\u{1fd0d}\u7072\uaa30\u3c84\u076e\u{1fb94}\u9f2d',
  layout: bindGroupLayout24,
  entries: [
    {binding: 197, resource: {buffer: buffer98, offset: 512, size: 1432}},
    {binding: 46, resource: textureView163},
  ],
});
let buffer216 = device0.createBuffer({size: 4464, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let computePassEncoder219 = commandEncoder147.beginComputePass({});
try {
computePassEncoder139.setBindGroup(2, bindGroup39);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle17]);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer47, 'uint16', 112, 1_824);
} catch {}
let buffer217 = device0.createBuffer({
  label: '\u3bc5\uecdf\u43f3',
  size: 5279,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: false,
});
let textureView304 = texture299.createView({arrayLayerCount: 1});
try {
computePassEncoder169.setBindGroup(3, bindGroup51, new Uint32Array(941), 151, 0);
} catch {}
try {
computePassEncoder142.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer61, 'uint16', 13_538, 1_525);
} catch {}
let promise30 = device0.queue.onSubmittedWorkDone();
let videoFrame44 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'unspecified'} });
let sampler153 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 82.92,
  lodMaxClamp: 84.71,
  maxAnisotropy: 1,
});
try {
computePassEncoder190.setBindGroup(0, bindGroup95, []);
} catch {}
try {
computePassEncoder86.setBindGroup(0, bindGroup120, new Uint32Array(185), 45, 0);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder46.setBindGroup(0, bindGroup60, new Uint32Array(521), 0, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer117, 'uint16', 214, 215);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await promise29;
} catch {}
try {
commandEncoder65.label = '\u{1fe0d}\u04cd\u{1faf8}';
} catch {}
let buffer218 = device0.createBuffer({size: 17809, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
computePassEncoder66.setBindGroup(1, bindGroup141, new Uint32Array(5759), 904, 0);
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup50);
} catch {}
let arrayBuffer23 = buffer71.getMappedRange(16, 0);
await gc();
let bindGroup159 = device0.createBindGroup({layout: bindGroupLayout15, entries: [{binding: 61, resource: textureView15}]});
try {
computePassEncoder7.setBindGroup(0, bindGroup141);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline5);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let bindGroup160 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 13, resource: {buffer: buffer80, offset: 2048}},
    {binding: 71, resource: textureView228},
    {binding: 162, resource: textureView64},
    {binding: 496, resource: {buffer: buffer158, offset: 512, size: 696}},
    {binding: 248, resource: textureView148},
  ],
});
let querySet37 = device0.createQuerySet({type: 'occlusion', count: 111});
try {
renderPassEncoder3.setIndexBuffer(buffer18, 'uint32', 2_376, 3_923);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer38.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture300 = device0.createTexture({size: [26, 20, 126], mipLevelCount: 2, format: 'r8uint', usage: GPUTextureUsage.COPY_DST});
let sampler154 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 60.84,
});
let externalTexture35 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'});
try {
computePassEncoder160.setBindGroup(3, bindGroup14);
} catch {}
try {
computePassEncoder204.setPipeline(pipeline2);
} catch {}
let videoFrame45 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'film', transfer: 'gamma22curve'} });
let pipelineLayout15 = device0.createPipelineLayout({label: '\u6a08\ue19e\u4a91\u{1f738}\u{1febd}\u4ffa', bindGroupLayouts: [bindGroupLayout4]});
let buffer219 = device0.createBuffer({
  label: '\u1406\u0676\u04ab\uc663\u66ff\u839f\u{1f74d}\u{1f85d}\u656d\u0153\u202b',
  size: 15859,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture301 = device0.createTexture({
  label: '\u0fe9\u{1fbcf}\u{1fd2f}',
  size: {width: 27, height: 4, depthOrArrayLayers: 156},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let textureView305 = texture277.createView({baseArrayLayer: 3, arrayLayerCount: 1});
try {
computePassEncoder14.setBindGroup(2, bindGroup89);
} catch {}
try {
computePassEncoder106.setBindGroup(1, bindGroup89, new Uint32Array(1057), 308, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer36, 'uint32', 428, 12_038);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(2, buffer74, 0, 228);
} catch {}
try {
  await promise30;
} catch {}
let texture302 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView306 = texture149.createView({baseMipLevel: 0});
try {
computePassEncoder157.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder45.setBindGroup(1, bindGroup124, new Uint32Array(905), 48, 0);
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle29, renderBundle31]);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(1, buffer75, 0, 11_061);
} catch {}
try {
device0.queue.writeBuffer(buffer18, 508, new DataView(new ArrayBuffer(11915)), 1378, 928);
} catch {}
let texture303 = device0.createTexture({
  size: {width: 1290},
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView307 = texture182.createView({aspect: 'all'});
let renderBundleEncoder41 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle41 = renderBundleEncoder41.finish({});
let sampler155 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 66.37,
  lodMaxClamp: 79.30,
});
try {
computePassEncoder195.setBindGroup(0, bindGroup18, new Uint32Array(768), 7, 0);
} catch {}
try {
computePassEncoder118.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder38.setBindGroup(0, bindGroup72);
} catch {}
try {
renderPassEncoder25.setScissorRect(16, 8, 0, 5);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer18, 'uint16', 1_712, 4_892);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(2, buffer2, 816, 2_152);
} catch {}
let promise31 = device0.queue.onSubmittedWorkDone();
await gc();
let buffer220 = device0.createBuffer({size: 934, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let textureView308 = texture182.createView({});
try {
renderPassEncoder25.setBindGroup(3, bindGroup15, new Uint32Array(835), 360, 0);
} catch {}
let texture304 = device0.createTexture({
  size: [161],
  sampleCount: 1,
  dimension: '1d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler156 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 50.61,
  lodMaxClamp: 52.70,
  compare: 'always',
  maxAnisotropy: 1,
});
try {
computePassEncoder177.setBindGroup(2, bindGroup51);
} catch {}
try {
computePassEncoder152.setBindGroup(3, bindGroup16, new Uint32Array(983), 164, 0);
} catch {}
try {
renderPassEncoder47.setBindGroup(1, bindGroup10, new Uint32Array(3535), 364, 0);
} catch {}
try {
renderPassEncoder50.executeBundles([renderBundle38]);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer83, 'uint16', 314, 1_251);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(1, buffer17, 0);
} catch {}
let buffer221 = device0.createBuffer({
  size: 1039,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder45.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder44.setVertexBuffer(5, buffer78, 0, 706);
} catch {}
let bindGroup161 = device0.createBindGroup({
  layout: bindGroupLayout31,
  entries: [{binding: 44, resource: {buffer: buffer97, offset: 256, size: 5477}}],
});
let buffer222 = device0.createBuffer({size: 6888, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let textureView309 = texture210.createView({
  label: '\u8868\u0faf\u{1fa05}\u0ca9',
  dimension: 'cube-array',
  mipLevelCount: 1,
  baseArrayLayer: 4,
  arrayLayerCount: 6,
});
let renderBundleEncoder42 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle42 = renderBundleEncoder42.finish({});
try {
computePassEncoder216.setPipeline(pipeline5);
} catch {}
try {
computePassEncoder85.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder50.setBindGroup(1, bindGroup85);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer43, 'uint32', 152, 232);
} catch {}
let arrayBuffer24 = buffer0.getMappedRange(80, 0);
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
if (!arrayBuffer20.detached) { new Uint8Array(arrayBuffer20).fill(0x55); };
} catch {}
let texture305 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView310 = texture73.createView({dimension: '2d-array', format: 'rgba32sint'});
try {
computePassEncoder160.setBindGroup(0, bindGroup92, []);
} catch {}
try {
computePassEncoder55.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder46.executeBundles([renderBundle42]);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(5, buffer55);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
await gc();
let querySet38 = device0.createQuerySet({type: 'occlusion', count: 387});
let textureView311 = texture240.createView({aspect: 'all'});
try {
renderPassEncoder38.setBindGroup(1, bindGroup151);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup66, new Uint32Array(3123), 861, 0);
} catch {}
try {
computePassEncoder191.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeBuffer(buffer18, 6392, new Float32Array(11636), 136, 560);
} catch {}
let buffer223 = device0.createBuffer({
  label: '\u057f\u5cbb\uff47\u{1fa4f}\u0222\u04d3\u0d91\uffd0\uc044',
  size: 393,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView312 = texture73.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder131.setPipeline(pipeline5);
} catch {}
try {
computePassEncoder177.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup102, new Uint32Array(4585), 346, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle28]);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline1);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeBuffer(buffer13, 280, new Int16Array(21472), 1467, 7148);
} catch {}
let textureView313 = texture290.createView({dimension: '1d', format: 'rg32float'});
let sampler157 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 71.17,
  lodMaxClamp: 80.80,
  compare: 'greater-equal',
});
try {
computePassEncoder211.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle17, renderBundle6, renderBundle7, renderBundle40, renderBundle39, renderBundle28, renderBundle7, renderBundle28, renderBundle6]);
} catch {}
try {
renderPassEncoder14.setViewport(34.82707478546377, 5.440738109332593, 2.3673489299114605, 0.954304302628477, 0.8019696820859789, 0.8799202531082938);
} catch {}
try {
  await promise31;
} catch {}
let bindGroupLayout37 = device0.createBindGroupLayout({
  label: '\u0a07\u{1f75b}\u0b6a\ue383\ubda7\ua41c\u00c9\u2dde\ub504\u{1f664}',
  entries: [
    {
      binding: 31,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 87,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 382,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 420,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 150,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 80,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
    {
      binding: 22,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 194,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 340,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 371,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 466,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 49,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 203,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 81,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true },
    },
    {
      binding: 62,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 34, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {
      binding: 33,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 72,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {binding: 145, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 486,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 21,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 70,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 26,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true },
    },
    {
      binding: 29,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 236,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 698,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 259,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 64, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 90,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 84,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {binding: 50, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 117, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 20,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 421,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 402,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 15, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 52,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 199,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {binding: 209, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }},
    {binding: 642, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }},
    {binding: 114, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 196, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }},
    {
      binding: 92,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 362,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {binding: 262, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }},
    {
      binding: 215,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 96,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 60,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 41,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 154, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 105,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 76,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 322, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {binding: 304, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {binding: 130, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 32,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 42,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {binding: 170, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 276, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 187, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let texture306 = device0.createTexture({
  label: '\u{1fa22}\u63fd\uf9e0\u{1feeb}',
  size: [26, 20, 32],
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder164.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture105,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(2_555).fill(76), /* required buffer size: 2_555 */
{offset: 35, bytesPerRow: 7, rowsPerImage: 15}, {width: 0, height: 0, depthOrArrayLayers: 25});
} catch {}
let texture307 = device0.createTexture({
  size: [2, 2, 2048],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture308 = device0.createTexture({
  size: [645],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder129.setBindGroup(2, bindGroup147, new Uint32Array(3131), 758, 0);
} catch {}
try {
computePassEncoder113.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup119);
} catch {}
try {
renderPassEncoder44.setPipeline(pipeline3);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup162 = device0.createBindGroup({layout: bindGroupLayout29, entries: [{binding: 166, resource: textureView266}]});
let textureView314 = texture306.createView({aspect: 'all'});
try {
computePassEncoder165.setBindGroup(0, bindGroup127, new Uint32Array(2074), 168, 0);
} catch {}
try {
renderPassEncoder49.setBindGroup(0, bindGroup130);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle18]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer24, 'uint32', 644, 2_500);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(5, buffer166);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
computePassEncoder147.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder181.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer122, 'uint32', 432, 24);
} catch {}
try {
gpuCanvasContext13.unconfigure();
} catch {}
let bindGroup163 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 389, resource: textureView140},
    {binding: 44, resource: sampler2},
    {binding: 8, resource: textureView117},
    {binding: 47, resource: textureView157},
    {binding: 255, resource: {buffer: buffer49, offset: 256}},
    {binding: 190, resource: textureView146},
    {binding: 523, resource: textureView169},
    {binding: 12, resource: {buffer: buffer6, offset: 7680, size: 8764}},
    {binding: 196, resource: textureView151},
    {binding: 349, resource: sampler66},
    {binding: 14, resource: {buffer: buffer140, offset: 1280, size: 279}},
    {binding: 6, resource: textureView238},
    {binding: 110, resource: textureView139},
    {binding: 70, resource: textureView149},
    {binding: 0, resource: {buffer: buffer13, offset: 768, size: 19368}},
    {binding: 287, resource: textureView92},
    {binding: 143, resource: {buffer: buffer20, offset: 2560, size: 4050}},
    {binding: 160, resource: textureView242},
    {binding: 163, resource: sampler11},
    {binding: 88, resource: textureView143},
    {binding: 306, resource: textureView90},
    {binding: 185, resource: textureView141},
    {binding: 68, resource: {buffer: buffer1, offset: 1024, size: 1321}},
    {binding: 195, resource: textureView294},
    {binding: 252, resource: {buffer: buffer52, offset: 1536, size: 380}},
    {binding: 177, resource: textureView109},
    {binding: 351, resource: {buffer: buffer13, offset: 7936, size: 348}},
    {binding: 79, resource: {buffer: buffer40, offset: 768, size: 2700}},
  ],
});
let texture309 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 78},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder68.setBindGroup(1, bindGroup66);
} catch {}
try {
computePassEncoder154.setBindGroup(0, bindGroup92, new Uint32Array(872), 180, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(0, bindGroup87, new Uint32Array(3581), 761, 0);
} catch {}
let videoFrame46 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte170m', transfer: 'iec61966-2-1'} });
let buffer224 = device0.createBuffer({
  label: '\u0ca3\u0f41\u{1fec4}',
  size: 9026,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView315 = texture233.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 1});
try {
renderPassEncoder16.executeBundles([renderBundle6, renderBundle2, renderBundle5]);
} catch {}
await gc();
let texture310 = device0.createTexture({
  label: '\u1a83\u0252\u08ef\u0c91\u6201\ub097\u{1f6ae}\u610d\u55d3\ua0d9',
  size: [13, 2, 78],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder175.setPipeline(pipeline5);
} catch {}
try {
computePassEncoder187.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder49.setBlendConstant({ r: -622.7, g: -382.3, b: -24.65, a: -779.2, });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 645, height: 4, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas4,
  origin: { x: 0, y: 16 },
  flipY: false,
}, {
  texture: texture66,
  mipLevel: 0,
  origin: {x: 94, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView316 = texture169.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 10});
try {
computePassEncoder111.setPipeline(pipeline5);
} catch {}
let arrayBuffer25 = buffer90.getMappedRange(8352, 32);
try {
renderPassEncoder32.insertDebugMarker('\u023a');
} catch {}
let textureView317 = texture306.createView({baseMipLevel: 0});
let textureView318 = texture150.createView({mipLevelCount: 1, baseArrayLayer: 41, arrayLayerCount: 21});
try {
computePassEncoder27.setBindGroup(3, bindGroup85);
} catch {}
try {
computePassEncoder104.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder47.setBindGroup(1, bindGroup115, new Uint32Array(1315), 995, 0);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle28, renderBundle3]);
} catch {}
let videoFrame47 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'bt709'} });
let videoFrame48 = new VideoFrame(videoFrame12, {timestamp: 0});
let texture311 = device0.createTexture({
  size: {width: 2},
  dimension: '1d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler158 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 29.68,
  lodMaxClamp: 56.65,
});
try {
renderPassEncoder44.setScissorRect(4, 0, 6, 3);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 176, new BigUint64Array(25293), 367, 92);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let texture312 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 16},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder212.setBindGroup(2, bindGroup66, new Uint32Array(240), 23, 0);
} catch {}
try {
computePassEncoder101.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup132);
} catch {}
try {
renderPassEncoder46.setBindGroup(1, bindGroup154, new Uint32Array(303), 17, 0);
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle18, renderBundle14]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer72, 808);
} catch {}
try {
buffer33.unmap();
} catch {}
let canvas7 = document.createElement('canvas');
let bindGroup164 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 136, resource: textureView36},
    {binding: 29, resource: textureView116},
    {binding: 7, resource: textureView228},
    {binding: 124, resource: textureView42},
    {binding: 112, resource: sampler57},
  ],
});
let textureView319 = texture235.createView({dimension: 'cube', format: 'rg8uint'});
try {
computePassEncoder97.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup153, new Uint32Array(28), 0, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(19);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer33, 'uint16', 1_942, 1_539);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas3,
  origin: { x: 18, y: 4 },
  flipY: true,
}, {
  texture: texture237,
  mipLevel: 0,
  origin: {x: 11, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext14 = canvas7.getContext('webgpu');
let sampler159 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 51.04,
  lodMaxClamp: 96.09,
});
try {
computePassEncoder115.setBindGroup(0, bindGroup79);
} catch {}
try {
computePassEncoder160.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup94);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder27.setBlendConstant({ r: 826.1, g: -221.0, b: -541.6, a: -355.7, });
} catch {}
try {
computePassEncoder112.setBindGroup(3, bindGroup74);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(1, buffer164, 312, 1_476);
} catch {}
let videoFrame49 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'iec61966-2-1'} });
let buffer225 = device0.createBuffer({
  size: 15723,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder37.setBindGroup(1, bindGroup130);
} catch {}
let bindGroupLayout38 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 347,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 34,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let texture313 = device0.createTexture({size: [2, 2, 27], format: 'rgba16uint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
computePassEncoder24.setBindGroup(2, bindGroup31);
} catch {}
try {
computePassEncoder93.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup69, new Uint32Array(120), 9, 0);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle27]);
} catch {}
try {
renderPassEncoder0.setStencilReference(698);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer210, 'uint32', 3_612, 172);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 34}
*/
{
  source: videoFrame44,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture233,
  mipLevel: 1,
  origin: {x: 2, y: 4, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let pipelineLayout16 = device0.createPipelineLayout({bindGroupLayouts: []});
try {
computePassEncoder54.setBindGroup(2, bindGroup129, new Uint32Array(1009), 472, 0);
} catch {}
let shaderModule10 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

@group(1) @binding(2) var tex76: texture_2d<f32>;

@group(1) @binding(5) var st22: texture_storage_3d<rg32float, write>;

@group(1) @binding(8) var tex77: texture_cube<f32>;

@group(1) @binding(15) var tex78: texture_depth_2d;

@group(1) @binding(20) var et15: texture_external;

@group(1) @binding(29) var sam21: sampler_comparison;

@group(1) @binding(33) var st23: texture_storage_1d<rgba8uint, write>;

@group(1) @binding(34) var sam22: sampler;

@group(1) @binding(38) var sam23: sampler;

@group(1) @binding(47) var sam24: sampler;

@group(1) @binding(49) var<storage, read_write> buffer226: array<vec4f, 92>;

@group(1) @binding(54) var et16: texture_external;

@group(1) @binding(55) var<storage, read> buffer227: FragmentOutput6;

@group(1) @binding(61) var st24: texture_storage_1d<bgra8unorm, write>;

@group(1) @binding(62) var sam25: sampler_comparison;

@group(1) @binding(65) var tex79: texture_depth_2d;

@group(1) @binding(67) var tex80: texture_2d<f32>;

@group(1) @binding(68) var<storage, read_write> buffer228: array<array<array<array<array<f16, 1>, 23>, 1>, 1>, 3>;

@group(1) @binding(95) var sam26: sampler;

@group(1) @binding(99) var<uniform> buffer229: array<mat2x4f, 1>;

@group(1) @binding(112) var tex81: texture_cube<f32>;

@group(1) @binding(117) var<uniform> buffer230: vec2f;

@group(1) @binding(118) var tex82: texture_depth_2d;

@group(1) @binding(125) var tex83: texture_depth_2d;

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

@group(1) @binding(141) var tex84: texture_cube<u32>;

@group(1) @binding(142) var tex85: texture_1d<u32>;

@group(1) @binding(161) var tex86: texture_2d<f32>;

@group(1) @binding(162) var st25: texture_storage_2d<rgba32sint, read>;

@group(1) @binding(195) var tex87: texture_2d<u32>;

@group(1) @binding(209) var tex88: texture_2d<u32>;

@group(1) @binding(216) var<uniform> buffer231: array<mat2x3f, 51>;

@group(1) @binding(228) var<storage, read> buffer232: array<i32, 784>;

@group(1) @binding(232) var<storage, read> buffer233: array<array<array<array<array<array<array<array<f16, 1>, 1>, 14>, 2>, 2>, 1>, 1>, 7>;

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

@group(1) @binding(328) var tex89: texture_2d<u32>;

@group(1) @binding(330) var<uniform> buffer235: array<mat4x3h, 1>;

@group(1) @binding(348) var tex90: texture_2d<u32>;

@group(1) @binding(408) var tex91: texture_1d<u32>;

@group(1) @binding(479) var et18: texture_external;

@group(1) @binding(712) var<storage, read> buffer236: array<array<array<array<f16, 1>, 4>, 56>>;

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

struct T1 {
  @align(16) @size(304) f0: array<vec2u>,
}

struct T2 {
  @align(4) @size(8) f0: f16,
  @size(8) f1: i32,
  @size(64) f2: mat3x4f,
  @size(248) f3: mat3x2f,
}

struct T3 {
  f0: vec2f,
}

struct T4 {
  @size(320) f0: array<mat4x3f, 4>,
}

struct FragmentOutput6 {
  @location(3) @interpolate(flat, sample) f0: vec4f,
  @location(0) f1: vec4u,
  @location(5) @interpolate(perspective) f2: f32,
}

@id(18345) override override20 = false;

override override21: u32 = 6;

override override22: f32;

fn fn0() {
  buffer228[u32(unconst_u32(503))][u32(unconst_u32(104))][u32(unconst_u32(23))][u32(unconst_u32(59))][u32(unconst_u32(198))] += (*&buffer228)[2][u32(unconst_u32(39))][u32(unconst_u32(355))][u32(unconst_u32(21))][0];
  let ptr181: ptr<storage, f16, read_write> = &(*&buffer228)[u32(unconst_u32(65))][u32(unconst_u32(215))][u32(unconst_u32(190))][u32(unconst_u32(172))][u32(unconst_u32(431))];
  var vf151: vec4h = tanh(vec4h(unconst_f16(456.4), unconst_f16(1794.5), unconst_f16(39702.5), unconst_f16(5444.0)));
  let ptr182: ptr<storage, f16, read_write> = &(*ptr181);
  let ptr183: ptr<storage, f16, read_write> = &(*&buffer228)[u32(unconst_u32(169))][u32(unconst_u32(252))][u32(unconst_u32(578))][22][0];
  let ptr184: ptr<storage, f16, read_write> = &buffer228[2][u32(unconst_u32(263))][0][22][0];
  let ptr185: ptr<storage, array<array<f16, 1>, 23>, read_write> = &buffer228[u32(unconst_u32(60))][0][0];
  var vf152: f32 = textureLoad(tex82, vec2i(unconst_i32(15), unconst_i32(15)), i32(unconst_i32(-72)));
  let ptr186: ptr<storage, array<array<array<array<f16, 1>, 23>, 1>, 1>, read_write> = &(*&buffer228)[2];
}

var<workgroup> vw29: atomic<u32>;

var<private> vp6 = modf(vec4f(0.4254, 0.03351, 0.4784, 0.09890));

var<private> vp7 = modf(vec3f(0.1900, 0.01751, 0.03070));

var<private> vp8: T3 = T3();

@fragment
fn fragment8(@location(0) a0: vec4i, @location(8) @interpolate(flat) a1: vec2u) -> FragmentOutput6 {
  var out: FragmentOutput6;
  vp6.whole += vec4f(f32((*&buffer234)[arrayLength(&(*&buffer234))][1][0][u32(buffer234[u32(unconst_u32(28))][1][0][0][0][0][2])][u32(unconst_u32(34))][u32(unconst_u32(328))][u32(unconst_u32(115))]));
  fn0();
  fn0();
  let vf153: vec4f = textureSampleLevel(tex86, sam22, vec2f(unconst_f32(0.2530), unconst_f32(0.05748)), f32(unconst_f32(0.8145)), clamp(vec2i(-141, -6), vec2i(-8), vec2i(7)));
  buffer228[u32(buffer234[u32(unconst_u32(86))][1][0][0][0][0][2])][u32(unconst_u32(53))][u32(unconst_u32(14))][u32(unconst_u32(352))][u32(unconst_u32(213))] -= (*&buffer228)[u32(unconst_u32(13))][u32(unconst_u32(400))][u32(buffer234[arrayLength(&buffer234)][1][0][u32(unconst_u32(279))][u32(unconst_u32(190))][0][u32(unconst_u32(132))])][u32(unconst_u32(271))][0];
  fn0();
  buffer234[u32((*&buffer234)[u32(unconst_u32(6))][1][0][0][0][0][2])][u32(unconst_u32(114))][u32(unconst_u32(313))][u32(unconst_u32(36))][u32(unconst_u32(135))][u32(unconst_u32(403))][u32(unconst_u32(245))] = buffer234[u32(unconst_u32(44))][u32(unconst_u32(52))][0][0][u32(unconst_u32(475))][0][u32(unconst_u32(7))];
  vp7.fract = vec3f(f32(buffer234[arrayLength(&buffer234)][1][u32(unconst_u32(246))][u32(unconst_u32(146))][0][0][2]));
  fn0();
  fn0();
  fn0();
  let ptr187: ptr<storage, f16, read_write> = &(*&buffer228)[2][0][0][22][0];
  vp6 = modf(vec4f(f32(buffer234[u32((*&buffer234)[u32(unconst_u32(130))][1][u32(unconst_u32(664))][0][0][0][2])][1][u32(unconst_u32(52))][0][0][0][2])));
  out.f2 = f32((*&buffer234)[u32(unconst_u32(464))][u32(unconst_u32(261))][u32(unconst_u32(571))][u32(unconst_u32(9))][u32(unconst_u32(671))][u32(unconst_u32(134))][2]);
  let ptr188: ptr<storage, array<f16, 3>, read_write> = &buffer234[u32((*&buffer234)[arrayLength(&(*&buffer234))][u32(unconst_u32(393))][0][u32(unconst_u32(600))][u32(unconst_u32(132))][u32(unconst_u32(109))][2])][u32(unconst_u32(240))][0][0][u32(unconst_u32(121))][u32(unconst_u32(170))];
  fn0();
  let ptr189: ptr<storage, f16, read_write> = &(*&buffer234)[arrayLength(&(*&buffer234))][1][0][0][0][0][u32(unconst_u32(233))];
  out.f1 *= unpack4xU8(u32(textureSampleLevel(tex82, sam22, vec2f(unconst_f32(0.4168), unconst_f32(0.3524)), i32(unconst_i32(271)))));
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let querySet39 = device0.createQuerySet({type: 'occlusion', count: 751});
try {
computePassEncoder139.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder50.end();
} catch {}
try {
renderPassEncoder45.executeBundles([renderBundle4, renderBundle0]);
} catch {}
try {
renderPassEncoder49.setPipeline(pipeline3);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder257.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2492 */
  offset: 2492,
  buffer: buffer32,
}, {
  texture: texture118,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder257.copyTextureToTexture({
  texture: texture136,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture245,
  mipLevel: 3,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let textureView320 = texture10.createView({});
let sampler160 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 69.62,
  lodMaxClamp: 77.61,
  maxAnisotropy: 15,
});
try {
renderPassEncoder7.setBindGroup(2, bindGroup87);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer78, 'uint16', 1_344, 6_881);
} catch {}
try {
buffer117.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
try {
computePassEncoder219.setBindGroup(0, bindGroup151, new Uint32Array(411), 5, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup40);
} catch {}
try {
computePassEncoder164.insertDebugMarker('\u{1f735}');
} catch {}
let videoFrame50 = new VideoFrame(videoFrame14, {timestamp: 0});
let buffer237 = device0.createBuffer({size: 13337, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let texture314 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView321 = texture230.createView({dimension: '1d', format: 'rg32float'});
let computePassEncoder220 = commandEncoder257.beginComputePass({});
try {
computePassEncoder108.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline3);
} catch {}
let buffer238 = device0.createBuffer({
  label: '\u{1fd97}\u{1f8a9}\ufebb\u0218',
  size: 28995,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder220.setBindGroup(1, bindGroup65);
} catch {}
try {
computePassEncoder176.setBindGroup(0, bindGroup127, new Uint32Array(492), 28, 0);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture283,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(19).fill(104), /* required buffer size: 19 */
{offset: 19}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler161 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 71.25,
  lodMaxClamp: 73.33,
  maxAnisotropy: 12,
});
try {
computePassEncoder195.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer208, 'uint32', 604, 605);
} catch {}
try {
buffer151.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer30, 2184, new DataView(new ArrayBuffer(6502)), 1565, 472);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer239 = device0.createBuffer({
  size: 814,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView322 = texture41.createView({dimension: '2d', baseMipLevel: 0, arrayLayerCount: 1});
let sampler162 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 90.39,
  lodMaxClamp: 91.88,
  compare: 'less-equal',
});
try {
computePassEncoder134.setBindGroup(3, bindGroup64);
} catch {}
try {
bindGroupLayout12.label = '\uc48d\u005f\u0938\u{1fdbf}\u345b\u{1fc26}\u{1fad6}';
} catch {}
let bindGroup165 = device0.createBindGroup({
  layout: bindGroupLayout32,
  entries: [
    {binding: 338, resource: {buffer: buffer84, offset: 1536, size: 21660}},
    {binding: 17, resource: {buffer: buffer179, offset: 3072}},
  ],
});
let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: []});
try {
renderPassEncoder23.setPipeline(pipeline1);
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); };
} catch {}
let texture315 = device0.createTexture({
  label: '\ub0e0\u94d0\u066e\u{1fe56}\u6807\u1efb\u07ab\u07d0',
  size: {width: 104, height: 80, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'eac-rg11unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder37.setBindGroup(2, bindGroup152, new Uint32Array(717), 103, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
computePassEncoder48.pushDebugGroup('\u5e68');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture142,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(261).fill(218), /* required buffer size: 261 */
{offset: 261, bytesPerRow: 263}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture316 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder20.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer168, 'uint16', 666, 991);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer89);
} catch {}
let imageBitmap10 = await createImageBitmap(imageData26);
let querySet40 = device0.createQuerySet({label: '\ub881\u063a\uac8a\u8bd8', type: 'occlusion', count: 172});
let sampler163 = device0.createSampler({
  label: '\u0e06\u0524\uc27f\u{1fcb1}\u7766\u{1feae}\ua15f\u68b6',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 19.38,
  lodMaxClamp: 89.27,
  maxAnisotropy: 1,
});
try {
computePassEncoder143.setBindGroup(2, bindGroup97);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder176); computePassEncoder176.dispatchWorkgroupsIndirect(buffer91, 3_056); };
} catch {}
try {
computePassEncoder70.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder41.setIndexBuffer(buffer179, 'uint32', 488, 887);
} catch {}
try {
computePassEncoder48.popDebugGroup();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer14, 304, new DataView(new ArrayBuffer(567)), 40, 200);
} catch {}
let bindGroup166 = device0.createBindGroup({
  label: '\u{1fa37}\ucd30\u{1f986}\u{1f9d9}\u{1fc70}\u5b12\u{1fee4}',
  layout: bindGroupLayout31,
  entries: [{binding: 44, resource: {buffer: buffer100, offset: 0, size: 5885}}],
});
let texture317 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 12},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder30.executeBundles([renderBundle17, renderBundle17, renderBundle39, renderBundle39, renderBundle26, renderBundle6, renderBundle39, renderBundle0, renderBundle3, renderBundle14]);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer102, 'uint16', 14_602, 1_923);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(7, buffer138, 0);
} catch {}
try {
renderPassEncoder12.pushDebugGroup('\u08df');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let videoFrame51 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'jedecP22Phosphors', transfer: 'unspecified'} });
let bindGroup167 = device0.createBindGroup({
  label: '\u0530\ue57a\ubbd5\u0038',
  layout: bindGroupLayout12,
  entries: [{binding: 293, resource: textureView284}],
});
try {
computePassEncoder137.setBindGroup(3, bindGroup11, new Uint32Array(492), 142, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView323 = texture265.createView({mipLevelCount: 1});
try {
computePassEncoder212.setBindGroup(1, bindGroup155);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder176); computePassEncoder176.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder15.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer80, 'uint16', 1_194, 70);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(3, buffer145);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(790).fill(11), /* required buffer size: 790 */
{offset: 146, bytesPerRow: 92, rowsPerImage: 7}, {width: 29, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
externalTexture21.label = '\u00d2\u{1fd73}\u{1f64c}\u53dd';
} catch {}
let texture318 = device0.createTexture({
  label: '\u89af\u6308\u08ea\u0f14\u{1fc8e}\u29ee\u{1f6dc}\u{1fef5}',
  size: {width: 13, height: 10, depthOrArrayLayers: 1},
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder70.setBindGroup(0, bindGroup159);
} catch {}
try {
computePassEncoder176.end();
} catch {}
try {
computePassEncoder37.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup124, new Uint32Array(3172), 373, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer31, 0, 1_726);
} catch {}
try {
commandEncoder217.copyBufferToBuffer(buffer12, 2444, buffer93, 964, 344);
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 41}
*/
{
  source: videoFrame23,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture204,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture319 = device0.createTexture({
  size: [1290],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView324 = texture3.createView({baseArrayLayer: 5, arrayLayerCount: 51});
let sampler164 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 53.07,
  lodMaxClamp: 55.96,
});
try {
computePassEncoder120.setBindGroup(2, bindGroup15, new Uint32Array(518), 24, 0);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(3, buffer121);
} catch {}
try {
renderPassEncoder12.popDebugGroup();
} catch {}
let textureView325 = texture193.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1});
let renderPassEncoder51 = commandEncoder217.beginRenderPass({
  label: '\u{1fe5c}\u08b7\u0570\ubaae\u4f99\u{1f6d8}\u040e\u0604\u954f\u2d51\u{1f9f5}',
  colorAttachments: [{
  view: textureView144,
  clearValue: { r: -989.2, g: 605.6, b: 741.3, a: -870.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet22,
});
let sampler165 = device0.createSampler({addressModeU: 'repeat', magFilter: 'nearest', lodMaxClamp: 47.33, compare: 'equal'});
try {
computePassEncoder67.setBindGroup(1, bindGroup3);
} catch {}
try {
computePassEncoder133.setBindGroup(2, bindGroup64, new Uint32Array(2311), 277, 0);
} catch {}
try {
computePassEncoder123.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder43.setBindGroup(1, bindGroup31, new Uint32Array(424), 336, 0);
} catch {}
try {
renderPassEncoder32.setBlendConstant({ r: 816.8, g: 285.2, b: 740.0, a: 337.3, });
} catch {}
try {
renderPassEncoder32.setVertexBuffer(5, buffer77, 460, 1_657);
} catch {}
let bindGroup168 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 162, resource: sampler145}, {binding: 28, resource: textureView126}],
});
let renderBundleEncoder43 = device0.createRenderBundleEncoder({
  label: '\u2da7\u45fa',
  colorFormats: ['r8uint'],
  depthStencilFormat: 'stencil8',
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder171.setBindGroup(1, bindGroup108, []);
} catch {}
try {
computePassEncoder16.setBindGroup(0, bindGroup150, new Uint32Array(360), 47, 0);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(0, buffer167, 620, 186);
} catch {}
try {
renderBundleEncoder43.setBindGroup(2, bindGroup24);
} catch {}
try {
renderBundleEncoder43.setBindGroup(3, bindGroup138, new Uint32Array(285), 3, 0);
} catch {}
try {
renderBundleEncoder43.setIndexBuffer(buffer36, 'uint32', 836, 2_678);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: videoFrame11,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 23},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext8.unconfigure();
} catch {}
try {
renderPassEncoder10.setVertexBuffer(2, buffer83, 1_048);
} catch {}
try {
renderBundleEncoder43.setBindGroup(3, bindGroup141);
} catch {}
try {
renderBundleEncoder43.setVertexBuffer(0, buffer210);
} catch {}
try {
buffer180.unmap();
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let buffer240 = device0.createBuffer({size: 6699, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let texture320 = device0.createTexture({
  size: [26, 20, 32],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let sampler166 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 21.75,
});
try {
computePassEncoder165.setBindGroup(1, bindGroup28, new Uint32Array(948), 162, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder41.setBlendConstant({ r: 930.2, g: -726.6, b: 98.48, a: -66.71, });
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer24, 8_448);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer210, 'uint16', 652, 2_406);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer238);
} catch {}
let bindGroupLayout39 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 18,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 36,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 41,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 114,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 83,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 113,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 60,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 172,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 55, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 130,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 50,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 143,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 165,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 69,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 175,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false },
    },
    {binding: 32, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {
      binding: 304,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 369,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 47,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 6, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 127,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 343,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 137,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 174,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 151,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 432,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 523,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 246,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 88,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 26,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 100, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 12,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 110,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 77, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {
      binding: 274,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 193,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 61, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 115,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {binding: 240, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {
      binding: 53,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 31,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 167,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 103,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 33,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let buffer241 = device0.createBuffer({
  size: 5725,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let texture321 = device0.createTexture({
  size: [110, 16, 1],
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle43 = renderBundleEncoder43.finish({});
try {
computePassEncoder20.setBindGroup(2, bindGroup26, new Uint32Array(502), 130, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup108);
} catch {}
try {
renderPassEncoder51.setBindGroup(3, bindGroup84, new Uint32Array(3693), 203, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder16.draw(104, 0, 601_358_938, 1);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer18, 220);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer52, 3_328);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(0, buffer238, 0, 2_887);
} catch {}
let textureView326 = texture118.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 6});
let textureView327 = texture253.createView({dimension: '2d', baseArrayLayer: 4});
let sampler167 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 66.76,
  lodMaxClamp: 74.02,
});
try {
computePassEncoder120.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder40.setBindGroup(1, bindGroup34, new Uint32Array(3474), 1_139, 0);
} catch {}
try {
renderPassEncoder16.drawIndexed(1, 0, 0, -1_244_414_632);
} catch {}
try {
renderPassEncoder16.drawIndexedIndirect(buffer177, 136);
} catch {}
try {
renderPassEncoder16.drawIndirect(buffer164, 576);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer16, 'uint32', 160, 8_789);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer72, 36, 1_143);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 645, height: 4, depthOrArrayLayers: 62}
*/
{
  source: imageData12,
  origin: { x: 10, y: 1 },
  flipY: true,
}, {
  texture: texture218,
  mipLevel: 1,
  origin: {x: 64, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView328 = texture263.createView({label: '\uf57b\u97c1\u0e4f\ubd63\u0141\uecc4\u05f6\u2c4d\uef80\u0b64', dimension: '3d'});
let textureView329 = texture198.createView({label: '\u77e5\u08f4\u3e20', dimension: '2d', baseArrayLayer: 3});
let renderBundleEncoder44 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint']});
let sampler168 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.947,
  maxAnisotropy: 12,
});
try {
computePassEncoder65.setBindGroup(2, bindGroup41);
} catch {}
try {
computePassEncoder160.setBindGroup(1, bindGroup40, new Uint32Array(2715), 169, 0);
} catch {}
try {
renderPassEncoder35.setBindGroup(0, bindGroup94);
} catch {}
try {
renderPassEncoder16.end();
} catch {}
try {
renderPassEncoder49.setVertexBuffer(4, buffer2, 5_124);
} catch {}
try {
renderBundleEncoder44.setBindGroup(0, bindGroup122, new Uint32Array(1174), 8, 0);
} catch {}
try {
commandEncoder83.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 212 */
  offset: 212,
  buffer: buffer221,
}, {
  texture: texture75,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder83.copyTextureToTexture({
  texture: texture92,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture92,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder83.resolveQuerySet(querySet10, 144, 89, buffer92, 8192);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer30, 344, new Int16Array(27977), 853, 16);
} catch {}
let bindGroup169 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 185, resource: textureView179},
    {binding: 8, resource: textureView304},
    {binding: 306, resource: textureView270},
    {binding: 79, resource: {buffer: buffer55, offset: 512, size: 140}},
    {binding: 252, resource: {buffer: buffer42, offset: 0}},
    {binding: 70, resource: textureView320},
    {binding: 287, resource: textureView95},
    {binding: 196, resource: textureView151},
    {binding: 163, resource: sampler126},
    {binding: 47, resource: textureView157},
    {binding: 190, resource: textureView254},
    {binding: 6, resource: textureView290},
    {binding: 195, resource: textureView316},
    {binding: 160, resource: textureView16},
    {binding: 351, resource: {buffer: buffer172, offset: 5120, size: 600}},
    {binding: 110, resource: textureView92},
    {binding: 177, resource: textureView110},
    {binding: 143, resource: {buffer: buffer137, offset: 0, size: 1055}},
    {binding: 14, resource: {buffer: buffer22, offset: 512, size: 1634}},
    {binding: 349, resource: sampler52},
    {binding: 523, resource: textureView278},
    {binding: 44, resource: sampler80},
    {binding: 389, resource: textureView181},
    {binding: 88, resource: textureView30},
    {binding: 0, resource: {buffer: buffer52, offset: 256, size: 3160}},
    {binding: 12, resource: {buffer: buffer5, offset: 4096}},
    {binding: 255, resource: {buffer: buffer98, offset: 256, size: 332}},
    {binding: 68, resource: {buffer: buffer2, offset: 0}},
  ],
});
let buffer242 = device0.createBuffer({
  size: 2707,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture322 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 46},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle44 = renderBundleEncoder44.finish();
try {
computePassEncoder35.setBindGroup(2, bindGroup120);
} catch {}
try {
computePassEncoder144.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer35, 'uint32', 228, 2_007);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer242);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let imageData36 = new ImageData(4, 16);
try {
adapter0.label = '\u0a55\u0588\ud88b\u0ee8\u8242\u0f19\u078b';
} catch {}
let bindGroup170 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer148, offset: 2304, size: 3615}},
    {binding: 37, resource: textureView47},
  ],
});
let buffer243 = device0.createBuffer({size: 27503, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let texture323 = device0.createTexture({
  label: '\u0d84\u{1fe15}\u5ae0\u{1f87e}\u01f3\u907b\u4d6c\u01a2\u0117',
  size: [52, 40, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView330 = texture49.createView({});
let renderPassEncoder52 = commandEncoder83.beginRenderPass({
  colorAttachments: [{
  view: textureView322,
  clearValue: { r: -292.5, g: -436.5, b: 986.5, a: 871.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder4.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder154.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(7, buffer2, 0, 1_581);
} catch {}
await gc();
let imageData37 = new ImageData(48, 12);
let buffer244 = device0.createBuffer({size: 8067, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture324 = device0.createTexture({
  label: '\u0c5f\u0b12\u0d48\u{1f74e}\u{1f8dc}\u0497\u{1f737}\uf53f\ue837\uede1\u86e6',
  size: {width: 52, height: 40, depthOrArrayLayers: 49},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture325 = device0.createTexture({
  size: [27, 4, 1],
  mipLevelCount: 2,
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler169 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 56.48,
  lodMaxClamp: 87.56,
  maxAnisotropy: 19,
});
try {
computePassEncoder130.setBindGroup(3, bindGroup59);
} catch {}
try {
computePassEncoder171.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle27, renderBundle31, renderBundle27, renderBundle42, renderBundle31]);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline1);
} catch {}
let texture326 = device0.createTexture({
  label: '\u8452\u0ef4\u1c08\u{1fd05}\u2bca\u73ce\u4a35',
  size: {width: 55, height: 8, depthOrArrayLayers: 312},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView331 = texture160.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder218.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer78, 'uint16', 6_170, 915);
} catch {}
canvas4.width = 151;
let texture327 = device0.createTexture({
  label: '\u9750\uf02a\u0670\u000e\u0872\u5570\u0d6b\u0e61\uc691\u1350\u623d',
  size: {width: 52, height: 40, depthOrArrayLayers: 102},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture328 = device0.createTexture({
  size: [13, 10, 1],
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView332 = texture326.createView({aspect: 'all', format: 'r32sint'});
let externalTexture36 = device0.importExternalTexture({source: videoFrame29, colorSpace: 'display-p3'});
try {
computePassEncoder214.setBindGroup(3, bindGroup93, new Uint32Array(1493), 133, 0);
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer204, 148, new Float32Array(5166), 318, 0);
} catch {}
try {
gpuCanvasContext11.unconfigure();
} catch {}
let buffer245 = device0.createBuffer({
  size: 6032,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture329 = device0.createTexture({
  size: [645, 4, 1],
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder133.setBindGroup(3, bindGroup58);
} catch {}
try {
computePassEncoder76.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeBuffer(buffer145, 1180, new Int16Array(5384), 862, 140);
} catch {}
let promise32 = device0.queue.onSubmittedWorkDone();
let bindGroup171 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 28, resource: textureView168}, {binding: 162, resource: sampler41}],
});
let buffer246 = device0.createBuffer({
  label: '\u530c\u6678\u1cd0\u{1fc5a}',
  size: 7215,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let textureView333 = texture329.createView({});
let texture330 = device0.createTexture({
  label: '\u{1f973}\u5d85\u0c59\u732b',
  size: {width: 161, height: 1, depthOrArrayLayers: 15},
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView334 = texture98.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder45 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder103.setBindGroup(3, bindGroup131);
} catch {}
try {
computePassEncoder174.setBindGroup(0, bindGroup20, new Uint32Array(85), 7, 0);
} catch {}
try {
computePassEncoder194.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle1, renderBundle18, renderBundle18]);
} catch {}
try {
renderBundleEncoder45.setIndexBuffer(buffer75, 'uint16', 2_952, 15_115);
} catch {}
try {
renderPassEncoder37.insertDebugMarker('\u76ac');
} catch {}
let imageData38 = new ImageData(88, 80);
let texture331 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 11},
  mipLevelCount: 2,
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle45 = renderBundleEncoder45.finish({});
try {
computePassEncoder86.setBindGroup(3, bindGroup55, new Uint32Array(3493), 866, 0);
} catch {}
try {
computePassEncoder109.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder22.setScissorRect(2, 0, 2, 7);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer3, 'uint16', 52, 5);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
let promise33 = device0.queue.onSubmittedWorkDone();
let texture332 = device0.createTexture({
  size: [645, 4, 1],
  mipLevelCount: 7,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView335 = texture138.createView({baseMipLevel: 0});
let sampler170 = device0.createSampler({
  label: '\u0963\ud8cf\u043d\u8a49\u0302',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 0.4758,
  lodMaxClamp: 85.80,
});
try {
computePassEncoder60.setBindGroup(0, bindGroup117);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup168);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer61, 'uint16', 3_822, 824);
} catch {}
try {
if (!arrayBuffer20.detached) { new Uint8Array(arrayBuffer20).fill(0x55); };
} catch {}
offscreenCanvas7.height = 471;
let bindGroup172 = device0.createBindGroup({
  label: '\u{1fdff}\u938a',
  layout: bindGroupLayout37,
  entries: [
    {binding: 72, resource: textureView236},
    {binding: 21, resource: {buffer: buffer49, offset: 0}},
    {binding: 236, resource: {buffer: buffer97, offset: 0, size: 323}},
    {binding: 34, resource: sampler14},
    {binding: 130, resource: sampler49},
    {binding: 276, resource: externalTexture6},
    {binding: 259, resource: textureView284},
    {binding: 698, resource: {buffer: buffer137, offset: 768, size: 192}},
    {binding: 114, resource: externalTexture22},
    {binding: 20, resource: sampler162},
    {binding: 70, resource: textureView197},
    {binding: 116, resource: textureView72},
    {binding: 154, resource: sampler126},
    {binding: 29, resource: {buffer: buffer62, offset: 768}},
    {binding: 26, resource: textureView237},
    {binding: 52, resource: {buffer: buffer139, offset: 0, size: 324}},
    {binding: 90, resource: {buffer: buffer207, offset: 0}},
    {binding: 187, resource: externalTexture8},
    {binding: 41, resource: {buffer: buffer177, offset: 512, size: 854}},
    {binding: 62, resource: {buffer: buffer139, offset: 512, size: 420}},
    {binding: 466, resource: textureView293},
    {binding: 371, resource: textureView109},
    {binding: 322, resource: sampler68},
    {binding: 32, resource: externalTexture27},
    {binding: 362, resource: sampler63},
    {binding: 13, resource: {buffer: buffer20, offset: 1024, size: 3256}},
    {binding: 60, resource: {buffer: buffer3, offset: 0, size: 30}},
    {binding: 64, resource: externalTexture19},
    {binding: 340, resource: textureView303},
    {binding: 170, resource: externalTexture13},
    {binding: 196, resource: sampler156},
    {binding: 96, resource: {buffer: buffer16, offset: 3328, size: 2297}},
    {binding: 76, resource: {buffer: buffer31, offset: 256, size: 569}},
    {binding: 31, resource: {buffer: buffer141, offset: 3840, size: 2552}},
    {binding: 42, resource: sampler3},
    {binding: 117, resource: sampler51},
    {binding: 194, resource: textureView296},
    {binding: 150, resource: textureView293},
    {binding: 105, resource: externalTexture6},
    {binding: 203, resource: textureView1},
    {binding: 49, resource: textureView110},
    {binding: 84, resource: sampler54},
    {binding: 92, resource: {buffer: buffer82, offset: 512, size: 8369}},
    {binding: 421, resource: {buffer: buffer98, offset: 3072, size: 379}},
    {binding: 486, resource: textureView74},
    {binding: 33, resource: {buffer: buffer95, offset: 768, size: 6912}},
    {binding: 87, resource: textureView95},
    {binding: 58, resource: textureView144},
    {binding: 215, resource: sampler56},
    {binding: 75, resource: textureView317},
    {binding: 382, resource: textureView316},
    {binding: 209, resource: sampler156},
    {binding: 420, resource: textureView110},
    {binding: 81, resource: textureView58},
    {binding: 80, resource: sampler46},
    {binding: 15, resource: externalTexture30},
    {binding: 304, resource: {buffer: buffer89, offset: 768, size: 7731}},
    {binding: 262, resource: sampler110},
    {binding: 402, resource: {buffer: buffer74, offset: 0, size: 614}},
    {binding: 22, resource: textureView308},
    {binding: 50, resource: externalTexture2},
    {binding: 145, resource: {buffer: buffer82, offset: 3328, size: 14352}},
    {binding: 642, resource: sampler137},
    {binding: 199, resource: externalTexture24},
    {binding: 2, resource: {buffer: buffer25, offset: 1024, size: 675}},
    {binding: 1, resource: sampler153},
  ],
});
try {
renderPassEncoder22.beginOcclusionQuery(74);
} catch {}
try {
buffer169.unmap();
} catch {}
document.body.prepend(img1);
let textureView336 = texture149.createView({label: '\u2c24\ua569\u0709\u3c9d\ud1f1', baseMipLevel: 0, mipLevelCount: 1});
let sampler171 = device0.createSampler({
  label: '\u0652\u4aff\ud766\u04ac\u0e75\u1ade\u7276\u0c4f\u4522\ufbdc',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 91.70,
  lodMaxClamp: 98.96,
});
try {
renderPassEncoder11.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(6, buffer77, 344, 122);
} catch {}
try {
renderPassEncoder18.insertDebugMarker('\u9084');
} catch {}
await gc();
let sampler172 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.26,
  lodMaxClamp: 92.43,
  maxAnisotropy: 12,
});
try {
renderPassEncoder37.setBindGroup(2, bindGroup119);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup65, new Uint32Array(2166), 981, 0);
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle18]);
} catch {}
let texture333 = device0.createTexture({
  size: [55, 8, 312],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView337 = texture243.createView({
  label: '\uf127\uabff\u{1fbe3}\u4777\u6b58\u58bc\u08c6',
  aspect: 'all',
  baseArrayLayer: 2,
  arrayLayerCount: 20,
});
let sampler173 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 51.40,
  lodMaxClamp: 62.17,
  compare: 'never',
});
try {
buffer61.unmap();
} catch {}
let textureView338 = texture183.createView({arrayLayerCount: 1});
let externalTexture37 = device0.importExternalTexture({source: videoFrame47});
try {
renderPassEncoder10.executeBundles([renderBundle6, renderBundle26, renderBundle1, renderBundle17, renderBundle1]);
} catch {}
let bindGroup173 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 219, resource: textureView61}]});
try {
computePassEncoder126.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder27.setBindGroup(1, bindGroup115, []);
} catch {}
try {
renderPassEncoder41.setIndexBuffer(buffer18, 'uint32', 632, 1_756);
} catch {}
let imageData39 = new ImageData(128, 64);
let sampler174 = device0.createSampler({
  label: '\u0245\u3d3e\u4e8c\u{1f807}\u{1fd23}\uf78d\u0361\u0044',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 62.20,
  lodMaxClamp: 69.99,
});
try {
computePassEncoder146.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup31, []);
} catch {}
try {
renderPassEncoder22.endOcclusionQuery();
} catch {}
try {
renderPassEncoder42.setVertexBuffer(7, buffer66, 3_632);
} catch {}
let texture334 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 78},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder14.setViewport(23.06252418582723, 4.256669261273385, 25.72330864205364, 0.2766062690031886, 0.3476318259962421, 0.7683638735836531);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let videoFrame52 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpte432', transfer: 'unspecified'} });
let textureView339 = texture182.createView({});
let textureView340 = texture229.createView({mipLevelCount: 1});
let sampler175 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 91.40,
  lodMaxClamp: 99.96,
});
try {
computePassEncoder27.setBindGroup(2, bindGroup5);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup152, new Uint32Array(1060), 4, 0);
} catch {}
try {
  await promise33;
} catch {}
let buffer247 = device0.createBuffer({label: '\u03bc\u2b0e', size: 15010, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let querySet41 = device0.createQuerySet({label: '\udcc7\ua39c\ub0d9', type: 'occlusion', count: 728});
let sampler176 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 81.14,
  lodMaxClamp: 85.13,
  maxAnisotropy: 15,
});
try {
computePassEncoder204.setBindGroup(0, bindGroup86, new Uint32Array(3709), 1_029, 0);
} catch {}
try {
computePassEncoder67.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle39]);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer238, 'uint32', 8_508, 6_947);
} catch {}
try {
gpuCanvasContext14.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroupLayout40 = device0.createBindGroupLayout({
  label: '\u{1fc98}\ua6be',
  entries: [
    {
      binding: 470,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer248 = device0.createBuffer({
  size: 6453,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture335 = device0.createTexture({
  label: '\u5c20\u6c57\u08f8\u0023\u6b49\uc51a\u{1f94d}\u87fc\uc8d3\u0f27\u31d7',
  size: [645, 4, 39],
  sampleCount: 1,
  dimension: '2d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture336 = device0.createTexture({
  size: [322, 2, 38],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32sint'],
});
try {
computePassEncoder167.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup13, new Uint32Array(2233), 231, 0);
} catch {}
try {
renderPassEncoder51.setIndexBuffer(buffer208, 'uint16', 1_558, 79);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture193,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(29).fill(118), /* required buffer size: 29 */
{offset: 29}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let querySet42 = device0.createQuerySet({type: 'occlusion', count: 111});
let sampler177 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 43.53,
  lodMaxClamp: 81.63,
  compare: 'less',
});
try {
computePassEncoder199.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup55);
} catch {}
try {
renderPassEncoder25.setBindGroup(3, bindGroup129, new Uint32Array(3584), 441, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer157, 'uint16', 794, 6);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(3, buffer137, 816, 1_149);
} catch {}
let bindGroup174 = device0.createBindGroup({
  label: '\u07cd\ud7ab\u7719\u{1f9f3}\u4b58\u0410\u0a1d\u8eaa\uca2c\u0f89',
  layout: bindGroupLayout32,
  entries: [
    {binding: 17, resource: {buffer: buffer95, offset: 1536, size: 5543}},
    {binding: 338, resource: {buffer: buffer177, offset: 256, size: 436}},
  ],
});
let buffer249 = device0.createBuffer({size: 1191, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let texture337 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 1},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView341 = texture289.createView({dimension: '2d-array', arrayLayerCount: 1});
let renderBundleEncoder46 = device0.createRenderBundleEncoder({colorFormats: ['r8uint'], depthStencilFormat: 'stencil8'});
try {
computePassEncoder169.setBindGroup(2, bindGroup25);
} catch {}
try {
computePassEncoder192.setBindGroup(0, bindGroup106, new Uint32Array(717), 145, 0);
} catch {}
try {
computePassEncoder208.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(4, buffer167, 248);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let textureView342 = texture253.createView({dimension: '2d', format: 'r16float', baseArrayLayer: 9});
let externalTexture38 = device0.importExternalTexture({source: videoFrame34});
try {
computePassEncoder170.setBindGroup(0, bindGroup26);
} catch {}
try {
computePassEncoder45.setBindGroup(3, bindGroup18, new Uint32Array(829), 198, 0);
} catch {}
try {
renderBundleEncoder46.setBindGroup(2, bindGroup102);
} catch {}
try {
renderBundleEncoder46.setBindGroup(0, bindGroup28, new Uint32Array(61), 32, 0);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(2, buffer31);
} catch {}
try {
device0.queue.writeBuffer(buffer223, 52, new DataView(new ArrayBuffer(525)), 38, 48);
} catch {}
try {
  await promise32;
} catch {}
let texture338 = device0.createTexture({
  size: [645],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder28.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup17);
} catch {}
try {
renderBundleEncoder46.setBindGroup(3, bindGroup7);
} catch {}
try {
renderBundleEncoder46.setBindGroup(0, bindGroup55, new Uint32Array(2583), 338, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let bindGroup175 = device0.createBindGroup({
  label: '\u3b8f\ufeb1\u1960\uef3c',
  layout: bindGroupLayout15,
  entries: [{binding: 61, resource: textureView296}],
});
let querySet43 = device0.createQuerySet({type: 'occlusion', count: 1392});
let textureView343 = texture215.createView({arrayLayerCount: 1});
let renderBundle46 = renderBundleEncoder46.finish({label: '\ua4ce\u{1f809}\u0bde\u3cd4'});
try {
computePassEncoder12.setBindGroup(0, bindGroup134, new Uint32Array(3303), 325, 0);
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup57, new Uint32Array(3839), 77, 0);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(1, buffer24, 1_804, 97);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: videoFrame47,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture237,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap11 = await createImageBitmap(videoFrame5);
try {
computePassEncoder69.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer242, 'uint32', 448, 26);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline3);
} catch {}
let bindGroup176 = device0.createBindGroup({
  layout: bindGroupLayout36,
  entries: [
    {binding: 170, resource: textureView304},
    {binding: 50, resource: textureView333},
    {binding: 35, resource: textureView304},
    {binding: 140, resource: {buffer: buffer205, offset: 256, size: 1024}},
    {binding: 105, resource: {buffer: buffer176, offset: 4352, size: 2454}},
  ],
});
let texture339 = device0.createTexture({
  label: '\u0587\u4c3f\u{1f6f5}\u1631\ud31c\u6fe6\ufd8e\ua3e8',
  size: {width: 110, height: 16, depthOrArrayLayers: 625},
  sampleCount: 1,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView344 = texture37.createView({dimension: '3d', baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder187.setBindGroup(0, bindGroup139);
} catch {}
try {
computePassEncoder189.setBindGroup(2, bindGroup84, new Uint32Array(326), 10, 0);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline5);
} catch {}
let promise34 = device0.queue.onSubmittedWorkDone();
try {
  await promise34;
} catch {}
let imageData40 = new ImageData(124, 4);
let textureView345 = texture269.createView({baseMipLevel: 0});
try {
computePassEncoder143.setBindGroup(1, bindGroup79, new Uint32Array(3029), 564, 0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup42, new Uint32Array(665), 29, 0);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer136, 'uint16', 7_714, 1_345);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
document.body.prepend(canvas7);
await gc();
let texture340 = gpuCanvasContext10.getCurrentTexture();
try {
computePassEncoder70.setBindGroup(3, bindGroup133);
} catch {}
try {
computePassEncoder159.end();
} catch {}
try {
computePassEncoder169.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(1, buffer21);
} catch {}
let arrayBuffer26 = buffer71.getMappedRange(48, 0);
try {
commandEncoder192.copyBufferToBuffer(buffer10, 3604, buffer166, 3484, 4220);
} catch {}
try {
device0.queue.writeBuffer(buffer77, 220, new Int16Array(44297), 16444, 352);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture341 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC,
});
let computePassEncoder221 = commandEncoder192.beginComputePass({});
try {
computePassEncoder112.setBindGroup(1, bindGroup167);
} catch {}
try {
computePassEncoder25.setBindGroup(1, bindGroup128, new Uint32Array(1622), 326, 0);
} catch {}
try {
computePassEncoder188.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder36.executeBundles([renderBundle31]);
} catch {}
let bindGroup177 = device0.createBindGroup({
  layout: bindGroupLayout20,
  entries: [
    {binding: 259, resource: {buffer: buffer97, offset: 1280, size: 563}},
    {binding: 27, resource: sampler55},
  ],
});
let querySet44 = device0.createQuerySet({type: 'occlusion', count: 221});
try {
computePassEncoder220.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, undefined);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 15}
*/
{
  source: videoFrame50,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let texture342 = device0.createTexture({
  label: '\u028a\u{1fb10}\u499c',
  size: [104, 80, 1],
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder49.setIndexBuffer(buffer102, 'uint16', 8_072, 6_448);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
document.body.append(canvas5);
let bindGroup178 = device0.createBindGroup({
  layout: bindGroupLayout37,
  entries: [
    {binding: 116, resource: textureView78},
    {binding: 33, resource: {buffer: buffer17, offset: 1024, size: 3288}},
    {binding: 170, resource: externalTexture13},
    {binding: 41, resource: {buffer: buffer3, offset: 0, size: 13}},
    {binding: 21, resource: {buffer: buffer240, offset: 3584, size: 1600}},
    {binding: 105, resource: externalTexture21},
    {binding: 486, resource: textureView28},
    {binding: 402, resource: {buffer: buffer221, offset: 256, size: 73}},
    {binding: 420, resource: textureView110},
    {binding: 42, resource: sampler167},
    {binding: 262, resource: sampler22},
    {binding: 187, resource: externalTexture31},
    {binding: 322, resource: sampler171},
    {binding: 203, resource: textureView3},
    {binding: 31, resource: {buffer: buffer42, offset: 256}},
    {binding: 194, resource: textureView296},
    {binding: 76, resource: {buffer: buffer100, offset: 1024}},
    {binding: 304, resource: {buffer: buffer17, offset: 1280, size: 6737}},
    {binding: 22, resource: textureView339},
    {binding: 62, resource: {buffer: buffer17, offset: 1024, size: 540}},
    {binding: 466, resource: textureView329},
    {binding: 52, resource: {buffer: buffer225, offset: 0, size: 356}},
    {binding: 236, resource: {buffer: buffer165, offset: 0, size: 469}},
    {binding: 150, resource: textureView98},
    {binding: 209, resource: sampler173},
    {binding: 13, resource: {buffer: buffer62, offset: 1024}},
    {binding: 276, resource: externalTexture33},
    {binding: 84, resource: sampler166},
    {binding: 58, resource: textureView55},
    {binding: 130, resource: sampler49},
    {binding: 75, resource: textureView317},
    {binding: 72, resource: textureView222},
    {binding: 215, resource: sampler102},
    {binding: 1, resource: sampler159},
    {binding: 87, resource: textureView303},
    {binding: 96, resource: {buffer: buffer138, offset: 512, size: 145}},
    {binding: 362, resource: sampler62},
    {binding: 642, resource: sampler130},
    {binding: 15, resource: externalTexture33},
    {binding: 70, resource: textureView109},
    {binding: 60, resource: {buffer: buffer176, offset: 2816, size: 9918}},
    {binding: 340, resource: textureView123},
    {binding: 49, resource: textureView284},
    {binding: 32, resource: externalTexture15},
    {binding: 34, resource: sampler88},
    {binding: 64, resource: externalTexture31},
    {binding: 50, resource: externalTexture8},
    {binding: 154, resource: sampler14},
    {binding: 117, resource: sampler145},
    {binding: 114, resource: externalTexture7},
    {binding: 199, resource: externalTexture35},
    {binding: 20, resource: sampler85},
    {binding: 698, resource: {buffer: buffer33, offset: 1024, size: 1072}},
    {binding: 421, resource: {buffer: buffer52, offset: 1024, size: 1835}},
    {binding: 92, resource: {buffer: buffer77, offset: 1024, size: 1323}},
    {binding: 382, resource: textureView157},
    {binding: 81, resource: textureView237},
    {binding: 29, resource: {buffer: buffer206, offset: 768}},
    {binding: 2, resource: {buffer: buffer9, offset: 1024, size: 846}},
    {binding: 259, resource: textureView109},
    {binding: 90, resource: {buffer: buffer97, offset: 256, size: 404}},
    {binding: 371, resource: textureView110},
    {binding: 145, resource: {buffer: buffer248, offset: 3072, size: 1499}},
    {binding: 26, resource: textureView58},
    {binding: 80, resource: sampler83},
    {binding: 196, resource: sampler76},
  ],
});
try {
computePassEncoder155.setBindGroup(3, bindGroup7);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 15}
*/
{
  source: videoFrame17,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap12 = await createImageBitmap(videoFrame21);
try {
globalThis.someLabel = bindGroupLayout24.label;
} catch {}
let bindGroup179 = device0.createBindGroup({
  layout: bindGroupLayout40,
  entries: [{binding: 470, resource: {buffer: buffer95, offset: 1536, size: 10324}}],
});
let texture343 = device0.createTexture({
  size: {width: 2},
  sampleCount: 1,
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler178 = device0.createSampler({
  label: '\ude60\u{1fae4}\u7761\u01b8\u581c\u3b55',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 58.49,
  lodMaxClamp: 96.15,
  maxAnisotropy: 14,
});
try {
computePassEncoder195.setPipeline(pipeline5);
} catch {}
try {
computePassEncoder185.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder29.setBindGroup(1, bindGroup106, new Uint32Array(545), 6, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(1, buffer219);
} catch {}
try {
computePassEncoder210.pushDebugGroup('\u0d9f');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let offscreenCanvas9 = new OffscreenCanvas(36, 284);
let buffer250 = device0.createBuffer({
  size: 18055,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder130.setBindGroup(0, bindGroup94);
} catch {}
try {
computePassEncoder198.setBindGroup(0, bindGroup4, new Uint32Array(1886), 425, 0);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle6, renderBundle26, renderBundle5, renderBundle4]);
} catch {}
let buffer251 = device0.createBuffer({
  size: 21034,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let textureView346 = texture126.createView({});
let externalTexture39 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder174.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle26]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer95);
} catch {}
try {
computePassEncoder210.popDebugGroup();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas1,
  origin: { x: 2, y: 7 },
  flipY: false,
}, {
  texture: texture167,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
texture180.label = '\u0147\u0617\udf76\u14b0\u0ac1\u94ba\u0f7b\uee79';
} catch {}
try {
computePassEncoder99.setBindGroup(2, bindGroup15);
} catch {}
try {
computePassEncoder213.setPipeline(pipeline5);
} catch {}
try {
computePassEncoder219.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer179, 'uint16', 2_358, 6_524);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
globalThis.someLabel = sampler18.label;
} catch {}
let buffer252 = device0.createBuffer({
  size: 7878,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
try {
computePassEncoder4.setPipeline(pipeline5);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 11}
*/
{
  source: imageData34,
  origin: { x: 5, y: 0 },
  flipY: false,
}, {
  texture: texture151,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder51.setIndexBuffer(buffer252, 'uint16', 184, 2_641);
} catch {}
let arrayBuffer27 = buffer90.getMappedRange(8504, 4);
try {
offscreenCanvas9.getContext('bitmaprenderer');
} catch {}
let textureView347 = texture333.createView({label: '\u09a2\u0325\u06f3\u21e7\ube5e\u{1f631}\uf5ba\u26d3\u{1f6b5}\u8735', mipLevelCount: 1});
try {
computePassEncoder93.setBindGroup(3, bindGroup153);
} catch {}
try {
computePassEncoder201.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline1);
} catch {}
await gc();
let texture344 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView348 = texture6.createView({});
try {
computePassEncoder107.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup79);
} catch {}
try {
renderPassEncoder47.beginOcclusionQuery(188);
} catch {}
try {
renderPassEncoder47.endOcclusionQuery();
} catch {}
try {
renderPassEncoder43.setVertexBuffer(1, buffer150, 2_180, 1_332);
} catch {}
let buffer253 = device0.createBuffer({size: 19001, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let textureView349 = texture118.createView({label: '\u{1fa99}\ufaaf\uf1e8\u1779\u0fca', dimension: 'cube', aspect: 'all', baseArrayLayer: 3});
let sampler179 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 80.75,
  maxAnisotropy: 16,
});
try {
computePassEncoder92.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder14.setViewport(38.143977885213985, 2.1245965428390123, 0.5712300797339536, 5.691326040236752, 0.06830820094664125, 0.5068905461327109);
} catch {}
let canvas8 = document.createElement('canvas');
let bindGroup180 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 31, resource: textureView67}]});
let textureView350 = texture263.createView({label: '\u{1f8cb}\u2671\u0a35'});
let texture345 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 32},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView351 = texture78.createView({});
try {
renderPassEncoder2.setIndexBuffer(buffer210, 'uint32', 692, 1_010);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, undefined, 0, 907_634_227);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let pipeline7 = await device0.createComputePipelineAsync({layout: pipelineLayout6, compute: {module: shaderModule9, entryPoint: 'compute9', constants: {}}});
let bindGroup181 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 25, resource: {buffer: buffer140, offset: 0, size: 426}},
    {binding: 0, resource: textureView316},
    {binding: 495, resource: {buffer: buffer138, offset: 3840, size: 336}},
    {binding: 268, resource: textureView320},
    {binding: 72, resource: {buffer: buffer185, offset: 6912}},
    {binding: 108, resource: {buffer: buffer7, offset: 0}},
    {binding: 58, resource: textureView266},
    {binding: 134, resource: textureView85},
    {binding: 156, resource: textureView296},
    {binding: 66, resource: textureView71},
    {binding: 207, resource: textureView55},
    {binding: 189, resource: textureView82},
    {binding: 8, resource: {buffer: buffer137, offset: 2560, size: 928}},
    {binding: 319, resource: externalTexture31},
  ],
});
let buffer254 = device0.createBuffer({label: '\u21e1\ua6d9\u0991', size: 4320, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView352 = texture19.createView({dimension: '2d', aspect: 'all', format: 'rg8uint', baseArrayLayer: 11});
try {
computePassEncoder172.setBindGroup(0, bindGroup78, new Uint32Array(444), 118, 0);
} catch {}
try {
computePassEncoder192.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle0, renderBundle5, renderBundle17]);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(1, buffer206);
} catch {}
let buffer255 = device0.createBuffer({
  size: 2012,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture346 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 27},
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder47 = device0.createRenderBundleEncoder({label: '\u0b7a\udac9\ufb05\u4f2a\u0810', colorFormats: ['rg8uint'], depthReadOnly: true});
try {
renderPassEncoder52.setVertexBuffer(7, buffer212, 0);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(5, buffer176);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float'],
});
} catch {}
try {
device0.queue.writeBuffer(buffer29, 13460, new BigUint64Array(64087), 22867, 28);
} catch {}
document.body.prepend(canvas8);
await gc();
let textureView353 = texture191.createView({label: '\u09c2\ubcb6\ue481', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0});
let renderBundle47 = renderBundleEncoder47.finish({});
try {
computePassEncoder150.setBindGroup(3, bindGroup128, new Uint32Array(339), 109, 0);
} catch {}
try {
renderPassEncoder39.setBindGroup(0, bindGroup74);
} catch {}
try {
renderPassEncoder39.drawIndexed(22, 60, 18, 50_018_647, 384_656_653);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer185, 'uint32', 3_404, 820);
} catch {}
let gpuCanvasContext15 = canvas8.getContext('webgpu');
let imageBitmap13 = await createImageBitmap(imageData11);
let bindGroup182 = device0.createBindGroup({
  layout: bindGroupLayout39,
  entries: [
    {binding: 12, resource: sampler87},
    {binding: 127, resource: {buffer: buffer240, offset: 256, size: 424}},
    {binding: 110, resource: {buffer: buffer56, offset: 256}},
    {binding: 47, resource: textureView81},
    {binding: 151, resource: textureView197},
    {binding: 432, resource: textureView141},
    {binding: 100, resource: sampler61},
    {binding: 172, resource: {buffer: buffer225, offset: 0, size: 812}},
    {binding: 240, resource: sampler143},
    {binding: 165, resource: textureView130},
    {binding: 246, resource: sampler73},
    {binding: 53, resource: {buffer: buffer118, offset: 512}},
    {binding: 193, resource: {buffer: buffer64, offset: 0}},
    {binding: 130, resource: textureView350},
    {binding: 369, resource: {buffer: buffer219, offset: 768, size: 3772}},
    {binding: 50, resource: textureView227},
    {binding: 44, resource: {buffer: buffer140, offset: 768, size: 1519}},
    {binding: 60, resource: textureView95},
    {binding: 16, resource: textureView100},
    {binding: 3, resource: {buffer: buffer37, offset: 1792, size: 6596}},
    {binding: 13, resource: textureView144},
    {binding: 113, resource: textureView320},
    {binding: 175, resource: textureView26},
    {binding: 143, resource: textureView290},
    {binding: 61, resource: externalTexture8},
    {binding: 167, resource: externalTexture39},
    {binding: 26, resource: sampler126},
    {binding: 304, resource: textureView65},
    {binding: 18, resource: textureView222},
    {binding: 77, resource: sampler116},
    {binding: 36, resource: {buffer: buffer29, offset: 16384}},
    {binding: 69, resource: textureView108},
    {binding: 523, resource: {buffer: buffer83, offset: 256}},
    {binding: 114, resource: textureView332},
    {binding: 55, resource: {buffer: buffer18, offset: 512, size: 2128}},
    {binding: 41, resource: textureView333},
    {binding: 115, resource: externalTexture23},
    {binding: 6, resource: externalTexture22},
    {binding: 103, resource: {buffer: buffer25, offset: 0, size: 1463}},
    {binding: 174, resource: textureView315},
    {binding: 37, resource: textureView75},
    {binding: 274, resource: {buffer: buffer137, offset: 512, size: 2168}},
    {binding: 31, resource: externalTexture0},
    {binding: 343, resource: {buffer: buffer98, offset: 1024, size: 596}},
    {binding: 137, resource: textureView326},
    {binding: 32, resource: sampler82},
    {binding: 88, resource: {buffer: buffer61, offset: 768, size: 4855}},
    {binding: 83, resource: {buffer: buffer17, offset: 0, size: 2648}},
    {binding: 33, resource: {buffer: buffer64, offset: 0}},
    {binding: 7, resource: {buffer: buffer209, offset: 1280, size: 372}},
  ],
});
let textureView354 = texture163.createView({dimension: '1d', aspect: 'all', baseMipLevel: 0});
let sampler180 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 71.95,
});
try {
computePassEncoder12.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder39.drawIndexed(20, 140, 11, 137_066_660, 41_265_769);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer255, 'uint16', 160, 30);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer72, 0, 2_274);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 8, new BigUint64Array(15435), 3227, 0);
} catch {}
let textureView355 = texture321.createView({label: '\uace4\u545b\u8c57\u036a\uab98'});
let textureView356 = texture24.createView({dimension: '3d', mipLevelCount: 1});
let sampler181 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 83.32,
  lodMaxClamp: 97.09,
  maxAnisotropy: 12,
});
try {
computePassEncoder48.setBindGroup(0, bindGroup152, new Uint32Array(1243), 127, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(2, bindGroup175, new Uint32Array(877), 137, 0);
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle29, renderBundle42, renderBundle42, renderBundle27]);
} catch {}
try {
renderPassEncoder24.setStencilReference(2001);
} catch {}
try {
renderPassEncoder39.draw(161_734_181, 8, 670_256_535, 571_977_090);
} catch {}
try {
renderPassEncoder39.drawIndexed(58, 189, 8, 45_555_329, 134_406_570);
} catch {}
try {
renderPassEncoder39.drawIndexedIndirect(buffer80, 376);
} catch {}
try {
renderPassEncoder39.drawIndirect(buffer3, 140);
} catch {}
try {
renderPassEncoder42.setVertexBuffer(3, buffer25, 156, 696);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 102}
*/
{
  source: videoFrame19,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture253,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 53},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer256 = device0.createBuffer({
  size: 16631,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let sampler182 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 68.35,
  compare: 'not-equal',
});
try {
renderPassEncoder8.beginOcclusionQuery(59);
} catch {}
try {
renderPassEncoder39.drawIndexed(19, 403, 15, 87_423_333, 198_122_823);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer72, 'uint32', 4_264, 3_148);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer150, 148, 1_563);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup183 = device0.createBindGroup({
  layout: bindGroupLayout35,
  entries: [{binding: 681, resource: {buffer: buffer22, offset: 3584, size: 100}}],
});
try {
computePassEncoder203.setBindGroup(0, bindGroup12, new Uint32Array(1716), 73, 0);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup171, new Uint32Array(2602), 294, 0);
} catch {}
try {
renderPassEncoder39.draw(749_468_654, 40, 1_204_776_463, 537_363_085);
} catch {}
try {
renderPassEncoder39.drawIndexed(1, 100, 7, 185_286_716, 508_206_809);
} catch {}
try {
renderPassEncoder39.drawIndexedIndirect(buffer177, 56);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(4, buffer37, 0, 3_129);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let bindGroup184 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView63},
    {binding: 285, resource: {buffer: buffer1, offset: 0, size: 3689}},
  ],
});
let sampler183 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 92.83,
  compare: 'never',
  maxAnisotropy: 18,
});
try {
computePassEncoder118.setBindGroup(0, bindGroup36);
} catch {}
try {
computePassEncoder200.setBindGroup(0, bindGroup64, new Uint32Array(291), 2, 0);
} catch {}
try {
renderPassEncoder39.end();
} catch {}
try {
renderPassEncoder18.setViewport(20.538916157045428, 6.979665835815179, 29.91535482690919, 0.615510139444814, 0.00814128429120764, 0.39902741447942486);
} catch {}
try {
buffer53.unmap();
} catch {}
try {
  await buffer217.mapAsync(GPUMapMode.READ, 0, 212);
} catch {}
let textureView357 = texture326.createView({});
let computePassEncoder222 = commandEncoder189.beginComputePass();
let sampler184 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.15,
  lodMaxClamp: 79.12,
});
try {
renderPassEncoder32.setBindGroup(0, bindGroup48);
} catch {}
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout6,
  multisample: {count: 4, mask: 0x498ab9f3},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment1',
  constants: {},
  targets: [{format: 'rg16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'dst', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.RED,
}, {format: 'rgba16float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {
  format: 'r16float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {module: shaderModule9, constants: {}, buffers: []},
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16'},
});
let sampler185 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 98.35,
  lodMaxClamp: 99.35,
});
try {
renderPassEncoder19.end();
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle4, renderBundle7, renderBundle28, renderBundle26, renderBundle17, renderBundle7]);
} catch {}
try {
commandEncoder91.copyBufferToBuffer(buffer246, 3952, buffer14, 132, 984);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer257 = device0.createBuffer({size: 16861, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder38.setBindGroup(2, bindGroup38, new Uint32Array(1353), 394, 0);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline7);
} catch {}
try {
buffer144.unmap();
} catch {}
try {
commandEncoder91.copyTextureToTexture({
  texture: texture337,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture100,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder91.insertDebugMarker('\u5a60');
} catch {}
await gc();
let buffer258 = device0.createBuffer({
  size: 27386,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView358 = texture290.createView({});
let computePassEncoder223 = commandEncoder91.beginComputePass({});
try {
computePassEncoder210.setBindGroup(2, bindGroup61);
} catch {}
try {
computePassEncoder135.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle14, renderBundle4, renderBundle47]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer166, 1_724, 1_757);
} catch {}
try {
computePassEncoder127.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup55, new Uint32Array(2252), 238, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer47, 'uint32', 4_828, 1_051);
} catch {}
let videoFrame53 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte170m', transfer: 'bt709'} });
let sampler186 = device0.createSampler({
  label: '\ua4f1\u0ac0\u0639',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 79.25,
});
try {
computePassEncoder23.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder52.setBindGroup(3, bindGroup60, new Uint32Array(646), 75, 0);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer117, 'uint16', 2_820, 113);
} catch {}
let texture347 = device0.createTexture({size: [55, 8, 312], dimension: '3d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
let sampler187 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 63.31,
  compare: 'less',
});
try {
computePassEncoder153.setBindGroup(1, bindGroup86, new Uint32Array(4169), 248, 0);
} catch {}
try {
computePassEncoder202.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder45.setBlendConstant({ r: 385.7, g: -971.5, b: 789.3, a: -847.0, });
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer241, 'uint32', 1_364, 204);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
gpuCanvasContext7.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
} catch {}
let bindGroup185 = device0.createBindGroup({
  label: '\u5b29\u0648\u{1f9ed}\u4b28',
  layout: bindGroupLayout9,
  entries: [
    {binding: 25, resource: {buffer: buffer89, offset: 6400, size: 6958}},
    {binding: 72, resource: {buffer: buffer43, offset: 0, size: 1028}},
    {binding: 108, resource: {buffer: buffer137, offset: 512, size: 539}},
    {binding: 66, resource: textureView71},
    {binding: 207, resource: textureView123},
    {binding: 8, resource: {buffer: buffer204, offset: 0, size: 96}},
    {binding: 134, resource: textureView78},
    {binding: 268, resource: textureView149},
    {binding: 495, resource: {buffer: buffer250, offset: 1792, size: 721}},
    {binding: 0, resource: textureView223},
    {binding: 189, resource: textureView82},
    {binding: 58, resource: textureView266},
    {binding: 319, resource: externalTexture2},
    {binding: 156, resource: textureView352},
  ],
});
let querySet45 = device0.createQuerySet({type: 'occlusion', count: 943});
let texture348 = device0.createTexture({
  label: '\u3b7b\u0f9b\u0681',
  size: [110, 16, 625],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView359 = texture20.createView({baseMipLevel: 1, mipLevelCount: 1});
try {
renderPassEncoder40.setBlendConstant({ r: 489.8, g: -279.7, b: 36.70, a: -547.9, });
} catch {}
try {
  await buffer162.mapAsync(GPUMapMode.WRITE, 72, 612);
} catch {}
let bindGroup186 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 90, resource: externalTexture32}, {binding: 348, resource: textureView5}],
});
let buffer259 = device0.createBuffer({
  size: 3876,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let sampler188 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 11.46,
});
try {
computePassEncoder127.setBindGroup(2, bindGroup180);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle47, renderBundle18]);
} catch {}
try {
renderPassEncoder44.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer253, 1320, new DataView(new ArrayBuffer(18657)), 4748, 7360);
} catch {}
let bindGroup187 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [
    {binding: 196, resource: sampler184},
    {binding: 380, resource: textureView51},
    {binding: 206, resource: textureView301},
    {binding: 74, resource: textureView62},
    {binding: 289, resource: textureView329},
    {binding: 119, resource: textureView233},
    {binding: 220, resource: textureView108},
    {binding: 230, resource: textureView178},
  ],
});
let texture349 = device0.createTexture({size: [27, 4, 32], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder20.setBindGroup(1, bindGroup29);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(6, buffer99);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 44, new Int16Array(12179), 156, 408);
} catch {}
try {
externalTexture39.label = '\uf1b0\u61c8\u21c2\u302f\u{1fb29}\u0c30\u{1fede}\u339b\ub257\u{1f74a}';
} catch {}
let texture350 = device0.createTexture({
  size: {width: 2},
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder198.setPipeline(pipeline5);
} catch {}
try {
buffer102.unmap();
} catch {}
let bindGroup188 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 248, resource: textureView50},
    {binding: 162, resource: textureView64},
    {binding: 496, resource: {buffer: buffer3, offset: 0, size: 272}},
    {binding: 71, resource: textureView145},
    {binding: 13, resource: {buffer: buffer209, offset: 256, size: 968}},
  ],
});
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer137, 420, new DataView(new ArrayBuffer(9895)), 2952, 80);
} catch {}
let promise35 = device0.queue.onSubmittedWorkDone();
let videoFrame54 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'log'} });
let videoFrame55 = videoFrame22.clone();
let bindGroup189 = device0.createBindGroup({
  layout: bindGroupLayout36,
  entries: [
    {binding: 105, resource: {buffer: buffer17, offset: 2048, size: 1524}},
    {binding: 170, resource: textureView208},
    {binding: 50, resource: textureView315},
    {binding: 140, resource: {buffer: buffer97, offset: 512, size: 1212}},
    {binding: 35, resource: textureView302},
  ],
});
let texture351 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 43},
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView360 = texture200.createView({dimension: '3d'});
let texture352 = device0.createTexture({
  size: [2, 2, 27],
  format: 'rg16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder75.setPipeline(pipeline7);
} catch {}
try {
buffer69.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer1, 3536, new DataView(new ArrayBuffer(43859)), 8862, 784);
} catch {}
document.body.append(img0);
let pipelineLayout18 = device0.createPipelineLayout({label: '\u07d7\ue044\u00ad\uf623\u55af\u0a5b', bindGroupLayouts: []});
let textureView361 = texture350.createView({});
try {
computePassEncoder116.setBindGroup(0, bindGroup115, new Uint32Array(170), 35, 0);
} catch {}
try {
computePassEncoder180.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer173, 'uint32', 1_168, 991);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer137);
} catch {}
let sampler189 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 73.25,
  maxAnisotropy: 5,
});
try {
renderPassEncoder8.setBindGroup(3, bindGroup106);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup96, new Uint32Array(662), 14, 0);
} catch {}
let arrayBuffer28 = buffer217.getMappedRange(24, 40);
let textureView362 = texture217.createView({label: '\u0214\u83ba', baseArrayLayer: 6, arrayLayerCount: 2});
try {
computePassEncoder179.setBindGroup(2, bindGroup19);
} catch {}
try {
computePassEncoder28.setBindGroup(1, bindGroup144, new Uint32Array(84), 16, 0);
} catch {}
try {
computePassEncoder218.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup128, new Uint32Array(478), 27, 0);
} catch {}
try {
renderPassEncoder30.setStencilReference(574);
} catch {}
try {
renderPassEncoder43.setVertexBuffer(5, buffer54, 1_472, 8_419);
} catch {}
try {
  await promise35;
} catch {}
let bindGroup190 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 384, resource: externalTexture15},
    {binding: 62, resource: sampler22},
    {binding: 328, resource: textureView296},
    {binding: 125, resource: textureView100},
    {binding: 141, resource: textureView75},
    {binding: 65, resource: textureView100},
    {binding: 232, resource: {buffer: buffer210, offset: 2304, size: 1936}},
    {binding: 61, resource: textureView17},
    {binding: 318, resource: {buffer: buffer49, offset: 0}},
    {binding: 36, resource: sampler136},
    {binding: 54, resource: externalTexture9},
    {binding: 49, resource: {buffer: buffer187, offset: 2304}},
    {binding: 68, resource: {buffer: buffer225, offset: 1280, size: 820}},
    {binding: 135, resource: externalTexture0},
    {binding: 8, resource: textureView266},
    {binding: 142, resource: textureView79},
    {binding: 47, resource: sampler83},
    {binding: 99, resource: {buffer: buffer25, offset: 256, size: 472}},
    {binding: 2, resource: textureView298},
    {binding: 55, resource: {buffer: buffer141, offset: 0, size: 3156}},
    {binding: 112, resource: textureView61},
    {binding: 33, resource: textureView271},
    {binding: 348, resource: textureView296},
    {binding: 712, resource: {buffer: buffer245, offset: 3072}},
    {binding: 34, resource: sampler186},
    {binding: 5, resource: textureView344},
    {binding: 117, resource: {buffer: buffer13, offset: 4608, size: 6262}},
    {binding: 162, resource: textureView199},
    {binding: 161, resource: textureView179},
    {binding: 216, resource: {buffer: buffer16, offset: 1280, size: 1892}},
    {binding: 479, resource: externalTexture28},
    {binding: 95, resource: sampler155},
    {binding: 118, resource: textureView110},
    {binding: 209, resource: textureView212},
    {binding: 195, resource: textureView212},
    {binding: 228, resource: {buffer: buffer17, offset: 256, size: 3312}},
    {binding: 38, resource: sampler42},
    {binding: 29, resource: sampler138},
    {binding: 408, resource: textureView348},
    {binding: 697, resource: {buffer: buffer152, offset: 8960, size: 1304}},
    {binding: 330, resource: {buffer: buffer258, offset: 2560, size: 15345}},
    {binding: 15, resource: textureView108},
    {binding: 20, resource: externalTexture12},
    {binding: 67, resource: textureView149},
  ],
});
let textureView363 = texture104.createView({baseArrayLayer: 48, arrayLayerCount: 6});
let renderBundleEncoder48 = device0.createRenderBundleEncoder({
  label: '\ua5a6\u5c09\u{1f806}\uc21d\u5d09\u08fe\u{1ff56}\ua5c4',
  colorFormats: ['rg32sint'],
  sampleCount: 1,
});
try {
computePassEncoder108.setBindGroup(0, bindGroup27, new Uint32Array(2427), 524, 0);
} catch {}
try {
computePassEncoder163.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer72);
} catch {}
let texture353 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 25},
  format: 'astc-8x8-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
let renderBundle48 = renderBundleEncoder48.finish({label: '\u0f04\u{1fd88}\u2f75\uf19d\u0d45\u46ca\u562e\ude4d\u{1fcd8}'});
try {
computePassEncoder169.setBindGroup(0, bindGroup21, new Uint32Array(85), 40, 0);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer34, 'uint32', 308, 2_713);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline1);
} catch {}
let imageData41 = new ImageData(32, 8);
let texture354 = device0.createTexture({size: [27, 4, 1], format: 'rg16uint', usage: GPUTextureUsage.COPY_DST});
let renderBundleEncoder49 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: false, stencilReadOnly: true});
try {
renderPassEncoder14.executeBundles([renderBundle18]);
} catch {}
try {
renderBundleEncoder49.setBindGroup(3, bindGroup87);
} catch {}
try {
renderBundleEncoder49.setBindGroup(2, bindGroup11, new Uint32Array(546), 28, 0);
} catch {}
try {
renderBundleEncoder49.setVertexBuffer(2, buffer91);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup191 = device0.createBindGroup({layout: bindGroupLayout29, entries: [{binding: 166, resource: textureView90}]});
let buffer260 = device0.createBuffer({
  size: 9846,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture355 = device0.createTexture({
  size: [52, 40, 6],
  format: 'etc2-rgb8a1unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView364 = texture202.createView({label: '\u7e93\ub544\u8dd3\u0e99\u03bb\u{1faa7}\u02ed\u002e', dimension: '2d-array', aspect: 'all'});
try {
computePassEncoder197.setBindGroup(0, bindGroup127, new Uint32Array(2736), 131, 0);
} catch {}
try {
renderBundleEncoder49.setBindGroup(0, bindGroup164, new Uint32Array(48), 12, 0);
} catch {}
let bindGroup192 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 347, resource: textureView272},
    {binding: 34, resource: {buffer: buffer97, offset: 2560, size: 2092}},
  ],
});
try {
computePassEncoder126.setBindGroup(3, bindGroup146);
} catch {}
try {
computePassEncoder96.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer183, 'uint16', 72, 208);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let bindGroup193 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 280, resource: sampler63},
    {binding: 217, resource: textureView55},
    {binding: 193, resource: sampler144},
    {binding: 384, resource: {buffer: buffer18, offset: 768, size: 3412}},
    {binding: 19, resource: textureView100},
    {binding: 76, resource: {buffer: buffer179, offset: 1536, size: 4025}},
    {binding: 191, resource: sampler77},
    {binding: 46, resource: textureView55},
    {binding: 309, resource: {buffer: buffer250, offset: 256, size: 3688}},
    {binding: 140, resource: textureView128},
    {binding: 136, resource: textureView110},
    {binding: 154, resource: sampler0},
    {binding: 388, resource: textureView333},
    {binding: 0, resource: sampler158},
    {binding: 65, resource: textureView266},
    {binding: 161, resource: {buffer: buffer98, offset: 1024, size: 3806}},
    {binding: 18, resource: sampler187},
    {binding: 44, resource: sampler183},
    {binding: 81, resource: textureView197},
    {binding: 146, resource: {buffer: buffer258, offset: 3584, size: 2164}},
    {binding: 130, resource: {buffer: buffer165, offset: 1024, size: 1065}},
    {binding: 75, resource: textureView97},
    {binding: 177, resource: sampler166},
    {binding: 216, resource: sampler132},
    {binding: 66, resource: textureView217},
    {binding: 20, resource: {buffer: buffer98, offset: 2560, size: 407}},
    {binding: 8, resource: sampler127},
    {binding: 61, resource: {buffer: buffer2, offset: 12032, size: 1132}},
    {binding: 21, resource: {buffer: buffer83, offset: 512}},
    {binding: 137, resource: {buffer: buffer172, offset: 2816, size: 1025}},
    {binding: 64, resource: {buffer: buffer8, offset: 7680}},
    {binding: 525, resource: {buffer: buffer122, offset: 0}},
    {binding: 51, resource: {buffer: buffer152, offset: 5888, size: 12680}},
    {binding: 29, resource: textureView100},
    {binding: 134, resource: externalTexture8},
    {binding: 119, resource: externalTexture23},
    {binding: 68, resource: sampler19},
    {binding: 160, resource: sampler185},
    {binding: 128, resource: {buffer: buffer91, offset: 0}},
    {binding: 132, resource: {buffer: buffer20, offset: 2048, size: 516}},
    {binding: 114, resource: textureView139},
    {binding: 56, resource: externalTexture3},
    {binding: 59, resource: textureView154},
    {binding: 307, resource: {buffer: buffer187, offset: 3584}},
    {binding: 133, resource: sampler91},
    {binding: 35, resource: textureView109},
    {binding: 87, resource: sampler94},
    {binding: 420, resource: sampler103},
    {binding: 413, resource: textureView99},
    {binding: 98, resource: {buffer: buffer22, offset: 2304, size: 490}},
    {binding: 90, resource: externalTexture39},
    {binding: 381, resource: {buffer: buffer44, offset: 3328, size: 3824}},
    {binding: 201, resource: textureView235},
    {binding: 58, resource: textureView60},
    {binding: 158, resource: textureView74},
    {binding: 107, resource: {buffer: buffer12, offset: 6656, size: 2354}},
    {binding: 153, resource: textureView3},
    {binding: 67, resource: externalTexture3},
    {binding: 22, resource: {buffer: buffer64, offset: 0, size: 355}},
    {binding: 104, resource: textureView237},
    {binding: 84, resource: externalTexture28},
    {binding: 45, resource: sampler187},
  ],
});
try {
computePassEncoder132.setBindGroup(0, bindGroup170);
} catch {}
let texture356 = device0.createTexture({
  label: '\u4a05\u{1fe78}',
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder14.setPipeline(pipeline7);
} catch {}
try {
computePassEncoder203.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder49.setVertexBuffer(2, undefined);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 5620, new DataView(new ArrayBuffer(645)), 25, 196);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
document.body.prepend(canvas2);
let buffer261 = device0.createBuffer({
  size: 4254,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder169.setBindGroup(3, bindGroup143, new Uint32Array(3756), 275, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder169); computePassEncoder169.dispatchWorkgroupsIndirect(buffer239, 132); };
} catch {}
try {
computePassEncoder40.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer141, 'uint16', 120, 439);
} catch {}
try {
renderBundleEncoder49.setBindGroup(2, bindGroup114, new Uint32Array(3024), 327, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 10, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData39,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture284,
  mipLevel: 4,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture357 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 30},
  dimension: '2d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle49 = renderBundleEncoder49.finish();
let sampler190 = device0.createSampler({
  label: '\u047b\u0258\u3c98\u05c4\ud535',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 70.10,
  lodMaxClamp: 93.04,
  maxAnisotropy: 2,
});
try {
renderPassEncoder46.setIndexBuffer(buffer173, 'uint16', 532, 198);
} catch {}
try {
buffer36.unmap();
} catch {}
let textureView365 = texture103.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder15.setBindGroup(0, bindGroup25, new Uint32Array(697), 191, 0);
} catch {}
try {
computePassEncoder33.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture203,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(129).fill(107), /* required buffer size: 129 */
{offset: 129, bytesPerRow: 47}, {width: 12, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture358 = device0.createTexture({
  label: '\u{1ff12}\uaf43\u024f\u0a9b\u{1fc08}\ud0a3\ua2e5\uc011\udce2\u0a7f',
  size: [13, 10, 9],
  mipLevelCount: 1,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler191 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  lodMinClamp: 70.56,
  lodMaxClamp: 85.91,
});
try {
computePassEncoder62.setBindGroup(2, bindGroup42, new Uint32Array(5014), 345, 0);
} catch {}
try {
computePassEncoder153.setPipeline(pipeline2);
} catch {}
let imageData42 = new ImageData(8, 16);
let bindGroup194 = device0.createBindGroup({layout: bindGroupLayout28, entries: [{binding: 423, resource: textureView284}]});
let textureView366 = texture118.createView({dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6});
let textureView367 = texture280.createView({label: '\u0f61\u{1fd39}\u07f9\u3ec3\u{1fb3c}\u0edb\ub758', dimension: '2d-array'});
try {
computePassEncoder89.setBindGroup(1, bindGroup159);
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup39, new Uint32Array(263), 3, 0);
} catch {}
try {
renderPassEncoder51.setViewport(11.948446803750267, 31.404586180025742, 23.91144100630042, 3.337846903268633, 0.6693340171948783, 0.7720738328605501);
} catch {}
try {
device0.queue.writeBuffer(buffer137, 816, new DataView(new ArrayBuffer(10282)), 854, 620);
} catch {}
let pipeline9 = device0.createRenderPipeline({
  layout: pipelineLayout9,
  multisample: {count: 4, mask: 0x81e96756},
  fragment: {
  module: shaderModule5,
  constants: {},
  targets: [{format: 'rg16uint', writeMask: 0}, {
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'src', dstFactor: 'one-minus-src-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'one-minus-src'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'rgba16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one', dstFactor: 'zero'},
    alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'r16float', writeMask: 0}],
},
  vertex: {module: shaderModule7, constants: {}, buffers: []},
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'},
});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
computePassEncoder134.setBindGroup(0, bindGroup183, new Uint32Array(754), 296, 0);
} catch {}
try {
computePassEncoder34.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup157);
} catch {}
let bindGroupLayout41 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 137,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let textureView368 = texture357.createView({label: '\u5f0a\u{1fa3a}\ue5a4\u148c', dimension: '2d', baseArrayLayer: 1});
try {
computePassEncoder97.setBindGroup(3, bindGroup58, new Uint32Array(1114), 93, 0);
} catch {}
try {
computePassEncoder80.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup9, new Uint32Array(4510), 2_283, 0);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle7, renderBundle17, renderBundle5, renderBundle7]);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer166, 0);
} catch {}
let arrayBuffer29 = buffer217.getMappedRange(0, 4);
try {
adapter0.label = '\u03f9\u{1fc28}\u8286\uad93\uc4fe\u05f5\u{1fdfc}\uc15f\u372d';
} catch {}
try {
computePassEncoder25.setBindGroup(2, bindGroup81);
} catch {}
try {
computePassEncoder21.setBindGroup(2, bindGroup4, new Uint32Array(1083), 409, 0);
} catch {}
try {
computePassEncoder44.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder27.setBindGroup(1, bindGroup106, new Uint32Array(53), 6, 0);
} catch {}
let videoFrame56 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'iec61966-2-1'} });
let sampler192 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 89.44,
});
try {
computePassEncoder101.setBindGroup(0, bindGroup76, new Uint32Array(390), 13, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder169); computePassEncoder169.dispatchWorkgroupsIndirect(buffer42, 800); };
} catch {}
try {
computePassEncoder169.end();
} catch {}
try {
renderPassEncoder21.setVertexBuffer(1, buffer31, 0, 2_492);
} catch {}
let bindGroup195 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 90, resource: externalTexture22}, {binding: 348, resource: textureView63}],
});
let textureView369 = texture341.createView({mipLevelCount: 1});
let sampler193 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 61.98,
  maxAnisotropy: 3,
});
try {
{ clearResourceUsages(device0, computePassEncoder108); computePassEncoder108.dispatchWorkgroupsIndirect(buffer38, 200); };
} catch {}
try {
computePassEncoder11.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder40.setBindGroup(0, bindGroup115);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(276);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer9, 'uint16', 1_736, 819);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
  await buffer211.mapAsync(GPUMapMode.READ, 136, 192);
} catch {}
try {
commandEncoder205.clearBuffer(buffer223, 56, 128);
} catch {}
let computePassEncoder224 = commandEncoder205.beginComputePass({});
let renderBundleEncoder50 = device0.createRenderBundleEncoder({
  label: '\u06f6\u1143\uc267\u03e7\ub4ec\u08cd\ucf86\u{1fb12}',
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  stencilReadOnly: true,
});
let renderBundle50 = renderBundleEncoder50.finish({label: '\u0e86\u52bf'});
let sampler194 = device0.createSampler({
  label: '\u{1fa37}\u{1f930}\u0e8b\u0996\u5e64\u03cc\u{1fc71}\ufa4f\u2c21\u09fd\u{1f9fa}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 75.20,
  lodMaxClamp: 83.92,
  compare: 'less',
  maxAnisotropy: 3,
});
try {
computePassEncoder108.end();
} catch {}
try {
computePassEncoder17.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer238, 'uint32', 28_992, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder126.clearBuffer(buffer200, 2928, 1556);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture216,
  mipLevel: 0,
  origin: {x: 31, y: 2, z: 1},
  aspect: 'all',
}, new Uint8Array(32).fill(43), /* required buffer size: 32 */
{offset: 32, bytesPerRow: 152}, {width: 29, height: 1, depthOrArrayLayers: 0});
} catch {}
let shaderModule11 = device0.createShaderModule({
  label: '\u042d\u0e07\ua985\u0053\u{1fad6}',
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(0) @binding(9) var<uniform> buffer262: mat2x2h;

@group(0) @binding(38) var st26: texture_storage_3d<rg32float, write>;

@group(0) @binding(107) var tex92: texture_1d<u32>;

@group(0) @binding(115) var tex93: texture_1d<i32>;

@group(0) @binding(245) var st27: texture_storage_3d<r32uint, read>;

@group(0) @binding(268) var tex94: texture_2d_array<u32>;

@group(0) @binding(296) var tex95: texture_2d<u32>;

struct T0 {
  f0: mat2x2h,
}

struct T1 {
  f0: array<u32>,
}

struct S8 {
  @location(14) @interpolate(linear, centroid) f0: vec2f,
}

struct S9 {
  @location(9) @interpolate(linear) f0: f16,
  @location(3) @interpolate(flat) f1: f32,
  @location(7) f2: vec4u,
}

struct VertexOutput12 {
  @location(2) @interpolate(flat, sample) f35: u32,
  @location(3) f36: vec4f,
  @builtin(position) f37: vec4f,
  @location(5) f38: f16,
}

@id(14028) override override23: u32;

override override24 = false;

@id(41906) override override25 = false;

@id(58295) override override26 = 0.08388;

override override27: f32;

@id(34089) override override28: f16;

override override29: f32;

@id(48454) override override30: f16;

fn fn0() -> S9 {
  var out: S9;
  out.f0 = f16(cosh(vec3f(unconst_f32(0.04686), unconst_f32(0.03002), unconst_f32(0.4861))).y);
  let vf154: f16 = acosh(normalize(vec2h(unconst_f16(6506.5), unconst_f16(10732.4))).g);
  var vf155: vec2h = normalize(vec2h(unconst_f16(4360.5), unconst_f16(11765.5)));
  vp9 = mat4x3f(f32(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), f32(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), f32(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), f32(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), f32(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), f32(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))), f32(pack2x16float(vec2f(unconst_f32(0.5224), unconst_f32(0.01103)))));
  vf155 = bitcast<vec2h>(countOneBits(i32(unconst_i32(109))));
  let vf156: bool = override24;
  out.f2 <<= vec4u(u32(distance(vec4f(unconst_f32(0.07565), unconst_f32(-0.1025), unconst_f32(-0.6463), unconst_f32(0.2892)), vec4f(unconst_f32(0.04172), unconst_f32(0.1683), unconst_f32(0.2228), unconst_f32(0.02844)))));
  out = S9(f16(override24), f32(override24), vec4u(u32(override24)));
  return out;
  _ = override24;
}

fn fn1() -> f16 {
  var out: f16;
  let vf157: f32 = vp9[u32(unconst_u32(15))][u32(unconst_u32(343))];
  let vf158: u32 = textureNumLevels(tex94);
  let ptr190: ptr<private, mat4x3f> = &vp9;
  textureStore(st26, vec3i(unconst_i32(394), unconst_i32(395), unconst_i32(335)), vec4f(vec4f(unconst_f32(0.2343), unconst_f32(0.1662), unconst_f32(0.08682), unconst_f32(0.06629))));
  out = exp2(exp2(vec3h(unconst_f16(7281.4), unconst_f16(8174.1), unconst_f16(9670.5)))).x;
  var vf159: vec4u = textureLoad(tex94, vec2i(unconst_i32(220), unconst_i32(76)), i32(unconst_i32(154)), i32(unconst_i32(64)));
  let ptr191: ptr<uniform, mat2x2h> = &(*&buffer262);
  textureStore(st26, vec3i(unconst_i32(984), unconst_i32(98), unconst_i32(9)), vec4f(vec4f((*ptr191)[u32(unconst_u32(150))].xxxy)));
  textureStore(st26, vec3i(unconst_i32(102), unconst_i32(51), unconst_i32(94)), vec4f(vec4f(unconst_f32(0.00621), unconst_f32(0.1748), unconst_f32(0.1352), unconst_f32(0.1400))));
  return out;
}

var<workgroup> vw30: S9;

var<workgroup> vw31: mat2x2h;

var<workgroup> vw32: i32;

var<workgroup> vw33: atomic<i32>;

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

@vertex
fn vertex13(@location(1) @interpolate(flat) a0: u32, a1: S8, a2: S9) -> VertexOutput12 {
  var out: VertexOutput12;
  fn0();
  out = VertexOutput12(u32(a2.f1), vec4f(a2.f1), vec4f(a2.f1), f16(a2.f1));
  vp9 = mat4x3f(vec3f(textureLoad(st27, vec3i(unconst_i32(42), unconst_i32(259), unconst_i32(294))).rag), vec3f(textureLoad(st27, vec3i(unconst_i32(42), unconst_i32(259), unconst_i32(294))).zzz), vec3f(textureLoad(st27, vec3i(unconst_i32(42), unconst_i32(259), unconst_i32(294))).bbr), bitcast<vec3f>(textureLoad(st27, vec3i(unconst_i32(42), unconst_i32(259), unconst_i32(294))).rga));
  var vf160 = fn0();
  var vf161: bool = override25;
  var vf162 = fn0();
  vp9 = mat4x3f(bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))), f32(pack4x8unorm(vec4f(unconst_f32(0.1110), unconst_f32(0.2139), unconst_f32(0.1136), unconst_f32(0.08742)))));
  vf160 = S9(vec4h(vf160.f2).a, vec4f(vf160.f2)[0], vf160.f2);
  out.f37 *= vec4f(mix(f32(smoothstep(vec4h(unconst_f16(11982.4), unconst_f16(958.1), unconst_f16(6040.0), unconst_f16(-22043.8)), vec4h(unconst_f16(8336.0), unconst_f16(9446.5), unconst_f16(1323.1), unconst_f16(5042.6)), vec4h(f16(vf162.f1))).b), f32(unconst_f32(0.2192)), f32(unconst_f32(0.1648))));
  var vf163 = fn0();
  var vf164 = fn0();
  var vf165: u32 = a2.f2[u32(unconst_u32(27))];
  var vf166 = fn0();
  fn0();
  out.f38 -= f16(vf163.f2.a);
  var vf167 = fn0();
  fn0();
  vf160 = S9(f16(radians(vec3f(unconst_f32(0.1494), unconst_f32(0.01458), unconst_f32(0.1313)))[2]), radians(vec3f(unconst_f32(0.1494), unconst_f32(0.01458), unconst_f32(0.1313))).b, bitcast<vec4u>(radians(vec3f(unconst_f32(0.1494), unconst_f32(0.01458), unconst_f32(0.1313))).ggbg));
  return out;
  _ = override24;
  _ = override25;
}

@compute @workgroup_size(1, 1, 1)
fn compute10() {
  let ptr192: ptr<workgroup, f32> = &(*&vw30).f1;
  atomicCompareExchangeWeak(&vw33, unconst_i32(61), unconst_i32(3));
}`,
  sourceMap: {},
  hints: {},
});
let texture359 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 119},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '2d',
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder62.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder38.setBindGroup(1, bindGroup85);
} catch {}
try {
renderPassEncoder46.setBindGroup(0, bindGroup114, new Uint32Array(67), 15, 0);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer64, 140, 71);
} catch {}
let texture360 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder53 = commandEncoder126.beginRenderPass({
  colorAttachments: [{
  view: textureView170,
  clearValue: { r: -900.8, g: -753.7, b: 551.1, a: -163.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet9,
});
let sampler195 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 97.96,
  lodMaxClamp: 99.23,
  compare: 'never',
  maxAnisotropy: 19,
});
try {
computePassEncoder194.setBindGroup(0, bindGroup170);
} catch {}
try {
gpuCanvasContext9.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING, colorSpace: 'srgb'});
} catch {}
let videoFrame57 = new VideoFrame(videoFrame37, {timestamp: 0});
let bindGroup196 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 49, resource: textureView108}, {binding: 134, resource: externalTexture31}],
});
let texture361 = device0.createTexture({
  label: '\u13dc\u0b63\u0dcb\u6013\u2296\u2542\u9d62\u0d14\u{1fdff}',
  size: {width: 645},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder63.setBindGroup(3, bindGroup149);
} catch {}
try {
computePassEncoder34.setBindGroup(1, bindGroup132, new Uint32Array(1667), 196, 0);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer24, 'uint16', 3_394, 2_666);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer224);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 380, new DataView(new ArrayBuffer(212)), 4, 44);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame33,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture238,
  mipLevel: 0,
  origin: {x: 56, y: 26, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture362 = device0.createTexture({
  label: '\u6f3b\ub1af\u851e\ua854\u{1f80c}\u0751\u9dc6',
  size: [52, 40, 64],
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler196 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 84.09,
  lodMaxClamp: 94.29,
});
try {
computePassEncoder62.setBindGroup(2, bindGroup108);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder197); computePassEncoder197.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder74.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup14);
} catch {}
try {
gpuCanvasContext15.unconfigure();
} catch {}
let buffer263 = device0.createBuffer({
  label: '\u6a1f\u0eb0\u908d\u03df\u{1f899}\u01d1\ufc54\u9dd8\ucf28\u0576\u0533',
  size: 7822,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let textureView370 = texture336.createView({dimension: '2d', baseArrayLayer: 2});
let textureView371 = texture228.createView({aspect: 'all'});
try {
renderPassEncoder48.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer207, 'uint32', 160, 67);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(5, buffer138);
} catch {}
let promise36 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: imageData31,
  origin: { x: 7, y: 6 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 14},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 8, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline10 = await device0.createComputePipelineAsync({layout: pipelineLayout6, compute: {module: shaderModule8}});
let texture363 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder26.setBindGroup(3, bindGroup19);
} catch {}
try {
computePassEncoder223.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder49.setBindGroup(1, bindGroup11, new Uint32Array(1501), 510, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer25, 'uint16', 160, 46);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 1364, new BigUint64Array(12326), 199, 316);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup197 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 41, resource: {buffer: buffer43, offset: 0, size: 180}},
    {binding: 107, resource: textureView196},
    {binding: 38, resource: textureView344},
    {binding: 9, resource: {buffer: buffer119, offset: 3584, size: 5970}},
    {binding: 245, resource: textureView34},
    {binding: 115, resource: textureView361},
    {binding: 268, resource: textureView129},
    {binding: 296, resource: textureView296},
  ],
});
let externalTexture40 = device0.importExternalTexture({source: videoFrame35, colorSpace: 'srgb'});
try {
computePassEncoder152.setBindGroup(2, bindGroup92);
} catch {}
try {
computePassEncoder178.setBindGroup(3, bindGroup154, new Uint32Array(530), 6, 0);
} catch {}
try {
computePassEncoder100.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer101, 'uint32', 700, 86);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder134.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder53.beginOcclusionQuery(171);
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle44, renderBundle44]);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(4, buffer171);
} catch {}
try {
device0.queue.writeBuffer(buffer94, 172, new BigUint64Array(636), 239, 12);
} catch {}
let pipelineLayout19 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture364 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 59},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder51 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
});
try {
{ clearResourceUsages(device0, computePassEncoder197); computePassEncoder197.dispatchWorkgroupsIndirect(buffer50, 2_372); };
} catch {}
try {
computePassEncoder81.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup137, new Uint32Array(715), 122, 0);
} catch {}
try {
renderPassEncoder43.executeBundles([renderBundle48]);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline3);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder98.copyBufferToBuffer(buffer87, 128, buffer257, 4192, 2448);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img0);
let bindGroup198 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 348, resource: textureView69}, {binding: 90, resource: externalTexture21}],
});
let commandBuffer5 = commandEncoder98.finish();
let texture365 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 5},
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler197 = device0.createSampler({
  label: '\u7c56\ud6a6',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 9.392,
  lodMaxClamp: 27.05,
});
try {
computePassEncoder79.setBindGroup(1, bindGroup67, new Uint32Array(905), 24, 0);
} catch {}
try {
computePassEncoder46.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder33.setScissorRect(6, 4, 0, 16);
} catch {}
try {
renderBundleEncoder51.setBindGroup(0, bindGroup78, new Uint32Array(4427), 3_097, 0);
} catch {}
let commandEncoder261 = device0.createCommandEncoder({});
let texture366 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 67},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder225 = commandEncoder261.beginComputePass({});
try {
computePassEncoder164.setBindGroup(3, bindGroup107);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder197); computePassEncoder197.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder182.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer75, 'uint32', 1_632, 4_835);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
try {
  await promise36;
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder51.setBindGroup(2, bindGroup59, new Uint32Array(580), 190, 0);
} catch {}
try {
renderBundleEncoder51.setIndexBuffer(buffer145, 'uint32', 2_124, 3_165);
} catch {}
try {
renderBundleEncoder51.setPipeline(pipeline4);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
computePassEncoder8.pushDebugGroup('\u{1f915}');
} catch {}
let textureView372 = texture3.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 15});
let renderBundle51 = renderBundleEncoder51.finish({});
let sampler198 = device0.createSampler({
  label: '\u93c7\u4f82\u03d1\u1324\u62e1',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.04,
  maxAnisotropy: 13,
});
let externalTexture41 = device0.importExternalTexture({source: videoFrame5});
try {
computePassEncoder147.setBindGroup(1, bindGroup32, new Uint32Array(470), 289, 0);
} catch {}
try {
computePassEncoder197.end();
} catch {}
try {
renderPassEncoder37.beginOcclusionQuery(29);
} catch {}
try {
buffer96.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(93).fill(30), /* required buffer size: 93 */
{offset: 93}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let computePassEncoder226 = commandEncoder229.beginComputePass({});
try {
renderPassEncoder30.setBindGroup(2, bindGroup119);
} catch {}
try {
renderPassEncoder42.setBindGroup(1, bindGroup13, new Uint32Array(6102), 1_446, 0);
} catch {}
try {
renderPassEncoder37.endOcclusionQuery();
} catch {}
try {
externalTexture2.label = '\u059b\uafca\u7a6c\u822b\u6c38\ue965\u{1fa94}';
} catch {}
try {
globalThis.someLabel = buffer29.label;
} catch {}
let querySet46 = device0.createQuerySet({type: 'occlusion', count: 869});
let texture367 = device0.createTexture({
  size: [13, 10, 101],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder53.endOcclusionQuery();
} catch {}
try {
renderPassEncoder29.executeBundles([renderBundle27]);
} catch {}
try {
renderPassEncoder41.setBlendConstant({ r: -866.9, g: -20.15, b: 612.8, a: 331.8, });
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer219, 'uint32', 2_648, 839);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder25.pushDebugGroup('\u379a');
} catch {}
try {
computePassEncoder25.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer156, 1368, new DataView(new ArrayBuffer(11250)), 1764, 456);
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); };
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture368 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 31},
  sampleCount: 1,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler199 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 20.48,
  lodMaxClamp: 93.60,
  maxAnisotropy: 10,
});
let externalTexture42 = device0.importExternalTexture({source: videoFrame51});
try {
computePassEncoder209.setBindGroup(3, bindGroup73, new Uint32Array(3953), 137, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer168, 'uint16', 998, 4_342);
} catch {}
try {
device0.queue.submit([commandBuffer5]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1290, height: 8, depthOrArrayLayers: 10}
*/
{
  source: imageBitmap11,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture215,
  mipLevel: 0,
  origin: {x: 273, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup199 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 28, resource: textureView293}, {binding: 162, resource: sampler178}],
});
try {
computePassEncoder25.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup167);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer148, 'uint32', 2_412, 83);
} catch {}
try {
device0.queue.writeBuffer(buffer77, 1004, new Int16Array(20951), 10233, 128);
} catch {}
let buffer264 = device0.createBuffer({
  size: 7146,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let querySet47 = device0.createQuerySet({type: 'occlusion', count: 162});
let texture369 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView373 = texture242.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 5, arrayLayerCount: 10});
try {
renderPassEncoder21.setPipeline(pipeline1);
} catch {}
try {
buffer52.unmap();
} catch {}
let texture370 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler200 = device0.createSampler({
  label: '\u96f8\u017d',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 57.35,
  lodMaxClamp: 91.87,
  compare: 'less',
});
try {
gpuCanvasContext4.unconfigure();
} catch {}
document.body.prepend(img0);
let texture371 = device0.createTexture({
  size: [52],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder211.setBindGroup(3, bindGroup104, new Uint32Array(1499), 46, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer145, 'uint32', 688, 1_227);
} catch {}
let arrayBuffer30 = buffer90.getMappedRange(8384, 0);
try {
device0.queue.writeBuffer(buffer80, 1124, new Int16Array(32940), 3530, 72);
} catch {}
let textureView374 = texture335.createView({label: '\ude33\u6231\ud874', baseArrayLayer: 5, arrayLayerCount: 4});
try {
computePassEncoder195.setBindGroup(1, bindGroup153);
} catch {}
try {
computePassEncoder65.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer33, 'uint32', 1_376, 9_485);
} catch {}
try {
buffer99.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder127.setBindGroup(1, bindGroup185, new Uint32Array(1049), 51, 0);
} catch {}
try {
renderPassEncoder38.executeBundles([renderBundle29]);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer8, 1_028);
} catch {}
try {
  await buffer59.mapAsync(GPUMapMode.WRITE, 0, 10988);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
let texture372 = device0.createTexture({
  size: [645, 4, 4],
  mipLevelCount: 1,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler201 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.95,
  lodMaxClamp: 97.13,
  compare: 'not-equal',
  maxAnisotropy: 19,
});
try {
computePassEncoder220.setBindGroup(3, bindGroup73, new Uint32Array(174), 59, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup157);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup131, new Uint32Array(1833), 331, 0);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle3, renderBundle3, renderBundle14]);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer223, 'uint32', 56, 70);
} catch {}
try {
computePassEncoder8.popDebugGroup();
} catch {}
let texture373 = device0.createTexture({
  label: '\ua048\uebe3\ue50c',
  size: [13],
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder27.setPipeline(pipeline10);
} catch {}
try {
device0.queue.writeBuffer(buffer180, 3752, new BigUint64Array(8411), 844, 172);
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
document.body.prepend(img0);
let shaderModule12 = device0.createShaderModule({
  label: '\uc65a\u072f\ud847\ube09\u{1f925}\u732d\u9a9f\u86f3\u7156\u9a15',
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

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

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

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

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

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

@group(1) @binding(2) var tex96: texture_2d<f32>;

@group(1) @binding(5) var st28: texture_storage_3d<rg32float, write>;

@group(1) @binding(8) var tex97: texture_cube<f32>;

@group(1) @binding(15) var tex98: texture_depth_2d;

@group(1) @binding(20) var et19: texture_external;

@group(1) @binding(29) var sam27: sampler_comparison;

@group(1) @binding(33) var st29: texture_storage_1d<rgba8uint, write>;

@group(1) @binding(34) var sam28: sampler;

@group(1) @binding(36) var sam29: sampler;

@group(1) @binding(38) var sam30: sampler;

@group(1) @binding(47) var sam31: sampler;

@group(1) @binding(49) var<storage, read_write> buffer265: array<array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 1>, 1>, 23>, 1>, 1>, 32>;

@group(1) @binding(54) var et20: texture_external;

@group(1) @binding(55) var<storage, read> buffer266: array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 9>, 2>;

@group(1) @binding(61) var st30: texture_storage_1d<bgra8unorm, write>;

@group(1) @binding(62) var sam32: sampler_comparison;

@group(1) @binding(65) var tex99: texture_depth_2d;

@group(1) @binding(67) var tex100: texture_2d<f32>;

@group(1) @binding(95) var sam33: sampler;

@group(1) @binding(99) var<uniform> buffer267: array<array<vec4f, 2>, 9>;

@group(1) @binding(112) var tex101: texture_cube<f32>;

@group(1) @binding(117) var<uniform> buffer268: vec2f;

@group(1) @binding(118) var tex102: texture_depth_2d;

@group(1) @binding(125) var tex103: texture_depth_2d;

@group(1) @binding(135) var et21: texture_external;

@group(1) @binding(141) var tex104: texture_cube<u32>;

@group(1) @binding(142) var tex105: texture_1d<u32>;

@group(1) @binding(161) var tex106: texture_2d<f32>;

@group(1) @binding(162) var st31: texture_storage_2d<rgba32sint, read>;

@group(1) @binding(195) var tex107: texture_2d<u32>;

@group(1) @binding(209) var tex108: texture_2d<u32>;

@group(1) @binding(216) var<uniform> buffer269: array<array<array<mat2x3h, 1>, 6>, 17>;

@group(1) @binding(228) var<storage, read> buffer270: array<array<array<array<u32, 8>, 14>, 7>>;

@group(1) @binding(232) var<storage, read> buffer271: array<array<array<array<vec2i, 1>, 1>, 98>>;

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

@group(1) @binding(328) var tex109: texture_2d<u32>;

@group(1) @binding(330) var<uniform> buffer273: array<array<mat2x2f, 1>, 1>;

@group(1) @binding(348) var tex110: texture_2d<u32>;

@group(1) @binding(384) var et22: texture_external;

@group(1) @binding(408) var tex111: texture_1d<u32>;

@group(1) @binding(479) var et23: texture_external;

@group(1) @binding(697) var<storage, read_write> buffer274: vec4u;

@group(1) @binding(712) var<storage, read> buffer275: array<array<array<array<f16, 8>, 7>, 4>>;

struct T0 {
  @size(272) f0: array<vec4u, 16>,
  @size(56) f1: mat3x2f,
}

struct T1 {
  f0: vec2u,
}

struct T2 {
  @size(176) f0: mat4x2f,
  @size(144) f1: array<vec4i, 1>,
}

alias vec3b = vec3<bool>;

var<workgroup> vw34: T1;

@compute @workgroup_size(1, 1, 2)
fn compute11() {
  textureBarrier();
  let ptr193: ptr<storage, f16, read_write> = &buffer265[u32(unconst_u32(257))][u32(unconst_u32(160))][u32(unconst_u32(55))][22][u32(unconst_u32(421))][0][0][0][0][u32(unconst_u32(22))];
  let ptr194: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer265[31][u32(unconst_u32(24))][0][u32(unconst_u32(74))][u32(unconst_u32(49))][0][u32(unconst_u32(200))][0];
  let ptr195: ptr<storage, array<f16, 1>, read_write> = &buffer265[31][0][0][u32(unconst_u32(105))][0][0][u32(unconst_u32(179))][0][u32(unconst_u32(53))];
  let ptr196: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 1>, read_write> = &buffer265[31][u32(unconst_u32(203))][0][u32(unconst_u32(24))][u32(unconst_u32(252))][u32(buffer266[1][8][0][0][u32(buffer265[31][u32(unconst_u32(216))][0][u32(unconst_u32(41))][u32(unconst_u32(160))][0][u32(unconst_u32(22))][u32(unconst_u32(20))][0][u32(unconst_u32(64))])][0])];
  let ptr197: ptr<uniform, mat2x2f> = &(*&buffer273)[0][0];
  let ptr198: ptr<storage, array<f16, 1>, read_write> = &(*&buffer265)[u32(unconst_u32(315))][0][0][u32(unconst_u32(115))][u32(buffer265[u32(unconst_u32(61))][u32(unconst_u32(243))][0][22][0][u32(buffer265[31][u32(unconst_u32(785))][0][u32(unconst_u32(28))][0][u32((*&buffer265)[31][0][u32(unconst_u32(119))][22][0][0][0][0][0][0])][0][0][0][u32(unconst_u32(66))])][0][0][u32(unconst_u32(248))][0])][u32(unconst_u32(96))][0][0][u32((*&buffer265)[u32(unconst_u32(4))][0][0][22][u32(unconst_u32(20))][0][0][0][u32(unconst_u32(518))][0])];
  let ptr199: ptr<storage, f16, read_write> = &buffer265[u32(unconst_u32(294))][0][0][u32(unconst_u32(43))][0][0][0][0][u32(unconst_u32(15))][u32(unconst_u32(672))];
}`,
  sourceMap: {},
  hints: {},
});
let sampler202 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 28.66});
try {
computePassEncoder150.setBindGroup(1, bindGroup199, []);
} catch {}
try {
computePassEncoder11.setBindGroup(0, bindGroup74, new Uint32Array(3741), 281, 0);
} catch {}
try {
computePassEncoder209.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer251, 'uint16', 4_538, 3_908);
} catch {}
try {
adapter0.label = '\u0d7f\u1d9a\u{1fb7a}\u7825\u9e0d\u{1fb96}\ud28d';
} catch {}
try {
computePassEncoder54.setBindGroup(3, bindGroup113);
} catch {}
try {
renderPassEncoder42.setBindGroup(0, bindGroup100, new Uint32Array(697), 49, 0);
} catch {}
try {
renderPassEncoder7.setScissorRect(7, 1, 5, 4);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(5, undefined, 59_056_353);
} catch {}
let bindGroup200 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 248, resource: textureView137},
    {binding: 162, resource: textureView99},
    {binding: 71, resource: textureView228},
    {binding: 496, resource: {buffer: buffer219, offset: 256, size: 2384}},
    {binding: 13, resource: {buffer: buffer260, offset: 768, size: 1277}},
  ],
});
let textureView375 = texture271.createView({dimension: '2d'});
try {
computePassEncoder196.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder37.setStencilReference(1078);
} catch {}
try {
renderPassEncoder25.setViewport(2.501113373729692, 0.0910810063340195, 14.292509774701672, 30.340446662713894, 0.21623607084675844, 0.6558551271232829);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer159, 'uint16', 22, 6);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame30,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture152,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext12.unconfigure();
} catch {}
let buffer276 = device0.createBuffer({size: 624, usage: GPUBufferUsage.STORAGE});
let textureView376 = texture330.createView({label: '\u{1fc4a}\u{1ff93}\u{1fed6}\u7f8d\u{1f91b}\u081e\u1680'});
try {
computePassEncoder13.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline1);
} catch {}
document.body.append(canvas2);
let videoFrame58 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'film', transfer: 'bt709'} });
let bindGroup201 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 14, resource: {buffer: buffer140, offset: 256, size: 451}},
    {binding: 160, resource: textureView356},
    {binding: 177, resource: textureView109},
    {binding: 252, resource: {buffer: buffer43, offset: 512, size: 428}},
    {binding: 68, resource: {buffer: buffer8, offset: 7680}},
    {binding: 6, resource: textureView298},
    {binding: 70, resource: textureView284},
    {binding: 255, resource: {buffer: buffer158, offset: 512, size: 620}},
    {binding: 47, resource: textureView177},
    {binding: 110, resource: textureView139},
    {binding: 190, resource: textureView146},
    {binding: 12, resource: {buffer: buffer18, offset: 2048, size: 1844}},
    {binding: 8, resource: textureView208},
    {binding: 195, resource: textureView157},
    {binding: 351, resource: {buffer: buffer225, offset: 768, size: 278}},
    {binding: 389, resource: textureView198},
    {binding: 287, resource: textureView144},
    {binding: 79, resource: {buffer: buffer82, offset: 1024, size: 2628}},
    {binding: 88, resource: textureView191},
    {binding: 306, resource: textureView75},
    {binding: 0, resource: {buffer: buffer84, offset: 12800, size: 6100}},
    {binding: 163, resource: sampler11},
    {binding: 185, resource: textureView141},
    {binding: 143, resource: {buffer: buffer242, offset: 256, size: 220}},
    {binding: 523, resource: textureView163},
    {binding: 349, resource: sampler15},
    {binding: 196, resource: textureView151},
    {binding: 44, resource: sampler159},
  ],
});
let texture374 = device0.createTexture({
  size: {width: 1290},
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture43 = device0.importExternalTexture({source: videoFrame26});
try {
renderPassEncoder42.setBindGroup(0, bindGroup34);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer1, 'uint16', 5_520, 306);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer82, 0);
} catch {}
let arrayBuffer31 = buffer217.getMappedRange(64, 44);
try {
device0.queue.writeBuffer(buffer66, 29624, new Float32Array(3396));
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
let sampler203 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 62.26,
  lodMaxClamp: 67.22,
});
try {
computePassEncoder206.setBindGroup(2, bindGroup65, new Uint32Array(950), 195, 0);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
let videoFrame59 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt709', transfer: 'smpte240m'} });
let texture375 = device0.createTexture({
  size: [26, 20, 1],
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler204 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 79.63,
  lodMaxClamp: 98.91,
  maxAnisotropy: 8,
});
try {
computePassEncoder196.setBindGroup(1, bindGroup51);
} catch {}
try {
computePassEncoder117.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup26);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup198, new Uint32Array(239), 51, 0);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer78, 'uint16', 1_034, 138);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let bindGroup202 = device0.createBindGroup({layout: bindGroupLayout30, entries: [{binding: 82, resource: textureView100}]});
let texture376 = device0.createTexture({
  label: '\u0b86\ucf04\u10fb\u1e75\uc045\u705c\u4bb6',
  size: {width: 322, height: 2, depthOrArrayLayers: 1},
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView377 = texture253.createView({
  label: '\ucac9\u19f7\uba21\ue92d\ub562\uee0c\ud823',
  dimension: '2d',
  mipLevelCount: 1,
  baseArrayLayer: 44,
  arrayLayerCount: 1,
});
let sampler205 = device0.createSampler({
  label: '\u00bf\u5f78\u02fa\ub4fe',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 99.84,
  compare: 'greater-equal',
});
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer101, 'uint32', 212, 121);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(0, buffer2, 8_072, 981);
} catch {}
try {
computePassEncoder214.setPipeline(pipeline7);
} catch {}
let externalTexture44 = device0.importExternalTexture({source: videoFrame9, colorSpace: 'display-p3'});
try {
renderPassEncoder34.setScissorRect(5, 0, 2, 4);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer216, 'uint16', 760, 481);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let texture377 = gpuCanvasContext12.getCurrentTexture();
let textureView378 = texture13.createView({mipLevelCount: 1});
let sampler206 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 72.98,
  lodMaxClamp: 97.09,
  maxAnisotropy: 1,
});
try {
renderPassEncoder37.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder51.setIndexBuffer(buffer39, 'uint32', 1_792, 801);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
await gc();
let texture378 = device0.createTexture({
  label: '\u0215\u03db\uf51f\u0eef\u05ad\u8dc3\uaaad',
  size: [230, 120, 1],
  mipLevelCount: 3,
  format: 'astc-10x5-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler207 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 57.17,
  lodMaxClamp: 89.01,
  maxAnisotropy: 13,
});
try {
computePassEncoder150.setBindGroup(1, bindGroup121);
} catch {}
try {
computePassEncoder6.setPipeline(pipeline10);
} catch {}
let bindGroup203 = device0.createBindGroup({
  layout: bindGroupLayout33,
  entries: [
    {binding: 137, resource: sampler78},
    {binding: 174, resource: {buffer: buffer95, offset: 4352, size: 368}},
    {binding: 121, resource: textureView296},
  ],
});
let texture379 = device0.createTexture({
  label: '\u0183\uc319\ue005\u00c2\u7fa9\u{1fc0e}\u765a',
  size: [26, 20, 1],
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture45 = device0.importExternalTexture({label: '\uc174\u62df\u{1fa7d}\u3009\u0f2c\u077e', source: videoFrame16});
try {
computePassEncoder64.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder44.setBindGroup(0, bindGroup203, new Uint32Array(629), 107, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer41, 0, 0);
} catch {}
try {
buffer181.unmap();
} catch {}
try {
computePassEncoder83.pushDebugGroup('\uc04a');
} catch {}
let texture380 = device0.createTexture({
  label: '\u0d64\ucc51\uc067\u057f\u{1fe9b}\u45d1\u5860\u7601\u{1f777}',
  size: {width: 110, height: 16, depthOrArrayLayers: 625},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder130.setBindGroup(2, bindGroup195);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1, 2); };
} catch {}
try {
computePassEncoder50.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder37.endOcclusionQuery();
} catch {}
try {
renderPassEncoder49.executeBundles([renderBundle38]);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer152, 'uint16', 1_500, 4_154);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(3, buffer251, 2_608);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture114,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(187).fill(75), /* required buffer size: 187 */
{offset: 187}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let videoFrame60 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'pq'} });
let buffer277 = device0.createBuffer({
  size: 1032,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
renderPassEncoder38.setBindGroup(3, bindGroup79);
} catch {}
try {
renderPassEncoder38.setBindGroup(0, bindGroup90, new Uint32Array(1659), 67, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle5, renderBundle1]);
} catch {}
try {
adapter0.label = '\u0115\udc5e\u15a0\u{1fdf4}\u59c0\u4cc7\u{1fccc}\ud566\ub112';
} catch {}
let buffer278 = device0.createBuffer({
  size: 6876,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let texture381 = device0.createTexture({
  size: [645, 4, 62],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder51.setBindGroup(0, bindGroup18);
} catch {}
try {
computePassEncoder50.setBindGroup(1, bindGroup90, new Uint32Array(242), 1, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder51.setBindGroup(2, bindGroup157);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(2);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle42, renderBundle31]);
} catch {}
let sampler208 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 78.38,
  maxAnisotropy: 15,
});
try {
computePassEncoder144.setBindGroup(3, bindGroup128);
} catch {}
try {
computePassEncoder11.end();
} catch {}
try {
computePassEncoder62.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer79, 'uint32', 4_416, 8_663);
} catch {}
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2892 */
  offset: 2892,
  bytesPerRow: 14848,
  rowsPerImage: 133,
  buffer: buffer251,
}, {
  texture: texture328,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder13.resolveQuerySet(querySet37, 4, 41, buffer76, 11264);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let bindGroup204 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 28, resource: textureView210}, {binding: 162, resource: sampler68}],
});
let sampler209 = device0.createSampler({addressModeU: 'clamp-to-edge', minFilter: 'nearest', lodMinClamp: 56.73, lodMaxClamp: 69.99});
try {
computePassEncoder168.setBindGroup(1, bindGroup67, new Uint32Array(2256), 434, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup114);
} catch {}
let textureView379 = texture127.createView({label: '\u0a30\u{1fb62}\uf9e0\u0d01\ua023\u3ff1'});
let computePassEncoder227 = commandEncoder13.beginComputePass({});
try {
renderPassEncoder17.setIndexBuffer(buffer212, 'uint16', 210, 1_063);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT, viewFormats: []});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame59,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture337,
  mipLevel: 0,
  origin: {x: 21, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let img2 = await imageWithData(36, 16, '#10101010', '#20202020');
let buffer279 = device0.createBuffer({
  size: 21852,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
try {
computePassEncoder225.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(2, buffer156, 0, 10_338);
} catch {}
try {
computePassEncoder21.insertDebugMarker('\u{1fdd9}');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture152,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(770).fill(148), /* required buffer size: 770 */
{offset: 770}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame61 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte432', transfer: 'unspecified'} });
let bindGroup205 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer250, offset: 4864, size: 4973}},
    {binding: 37, resource: textureView63},
  ],
});
let buffer280 = device0.createBuffer({
  label: '\u6375\u8682\uba4b\u0d4e\u9608\u363d\uf0f8\u{1fd14}\u{1fab2}\ufc6d',
  size: 248,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView380 = texture257.createView({label: '\u08f2\u2640\uf2c8\u4245\u0eb7\u52d9\u0528\u0679\u6619', dimension: '2d-array'});
try {
computePassEncoder105.setBindGroup(2, bindGroup86, new Uint32Array(8237), 2_750, 0);
} catch {}
try {
computePassEncoder165.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder36.setBindGroup(0, bindGroup155, new Uint32Array(4330), 1_247, 0);
} catch {}
let bindGroupLayout42 = device0.createBindGroupLayout({
  label: '\u033b\ud1e3\u0aff',
  entries: [
    {
      binding: 17,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 31,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 306,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 59,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let textureView381 = texture303.createView({format: 'rg32sint', arrayLayerCount: 1});
let sampler210 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 11,
});
try {
{ clearResourceUsages(device0, computePassEncoder165); computePassEncoder165.dispatchWorkgroupsIndirect(buffer221, 40); };
} catch {}
try {
renderPassEncoder22.insertDebugMarker('\u{1f631}');
} catch {}
let buffer281 = device0.createBuffer({size: 886, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let querySet48 = device0.createQuerySet({type: 'occlusion', count: 179});
try {
computePassEncoder218.setBindGroup(1, bindGroup12, new Uint32Array(305), 34, 0);
} catch {}
try {
computePassEncoder79.setPipeline(pipeline7);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let bindGroup206 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let querySet49 = device0.createQuerySet({type: 'occlusion', count: 1});
try {
computePassEncoder89.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
try {
buffer170.unmap();
} catch {}
let imageData43 = new ImageData(8, 16);
let bindGroupLayout43 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 511, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
  ],
});
let texture382 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView382 = texture218.createView({label: '\u{1fbfe}\ub73a\u0069\u0bb1\u84da\u40d3\u{1f9fb}\uf01e\u02ab\u7ffe', mipLevelCount: 1});
try {
computePassEncoder165.setBindGroup(3, bindGroup157, []);
} catch {}
try {
computePassEncoder79.setBindGroup(2, bindGroup92, new Uint32Array(1503), 1_149, 0);
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer212, 'uint32', 1_404, 70);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let bindGroup207 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 389, resource: textureView55}, {binding: 148, resource: textureView110}],
});
let pipelineLayout20 = device0.createPipelineLayout({bindGroupLayouts: []});
try {
computePassEncoder32.setBindGroup(2, bindGroup159, []);
} catch {}
try {
computePassEncoder161.setBindGroup(0, bindGroup75, new Uint32Array(998), 143, 0);
} catch {}
try {
computePassEncoder150.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle31, renderBundle29, renderBundle48, renderBundle27, renderBundle29]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture383 = device0.createTexture({
  size: {width: 27},
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler211 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 53.23,
  lodMaxClamp: 67.60,
});
try {
computePassEncoder102.setBindGroup(1, bindGroup79);
} catch {}
try {
computePassEncoder37.setBindGroup(0, bindGroup74, new Uint32Array(690), 82, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroupsIndirect(buffer82, 568); };
} catch {}
try {
computePassEncoder54.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup57);
} catch {}
try {
renderPassEncoder45.setBindGroup(3, bindGroup61, new Uint32Array(153), 37, 0);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(6);
} catch {}
let texture384 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView383 = texture57.createView({dimension: '2d-array'});
try {
buffer102.unmap();
} catch {}
let bindGroup208 = device0.createBindGroup({
  label: '\u{1fd12}\u{1fcbc}\u0533\u{1fe51}\u0f73\u0ed7\uf150\u9413\u15fe',
  layout: bindGroupLayout40,
  entries: [{binding: 470, resource: {buffer: buffer207, offset: 0}}],
});
let pipelineLayout21 = device0.createPipelineLayout({bindGroupLayouts: []});
try {
computePassEncoder192.setBindGroup(2, bindGroup206, []);
} catch {}
try {
computePassEncoder224.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture369,
  mipLevel: 2,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(74).fill(9), /* required buffer size: 74 */
{offset: 74, bytesPerRow: 495}, {width: 59, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup209 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let textureView384 = texture154.createView({mipLevelCount: 1});
let externalTexture46 = device0.importExternalTexture({source: videoFrame9});
try {
computePassEncoder86.setBindGroup(1, bindGroup38);
} catch {}
try {
computePassEncoder115.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder37.setViewport(40.02160094225956, 34.44919634064262, 1.0812022766611527, 4.191143537839213, 0.4926150610130272, 0.6222064875611278);
} catch {}
try {
if (!arrayBuffer20.detached) { new Uint8Array(arrayBuffer20).fill(0x55); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer278, 40); };
} catch {}
try {
computePassEncoder206.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder158.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder45.setBindGroup(0, bindGroup189, new Uint32Array(1303), 34, 1);
} catch {}
let bindGroup210 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 112, resource: sampler62},
    {binding: 124, resource: textureView20},
    {binding: 136, resource: textureView36},
    {binding: 29, resource: textureView164},
    {binding: 7, resource: textureView15},
  ],
});
let buffer282 = device0.createBuffer({
  size: 320,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder22.setIndexBuffer(buffer77, 'uint32', 1_196, 21);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(5, buffer119, 3_608, 1_339);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 6, height: 1, depthOrArrayLayers: 39}
*/
{
  source: videoFrame37,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture334,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup211 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 389, resource: textureView55}, {binding: 148, resource: textureView109}],
});
let buffer283 = device0.createBuffer({
  label: '\u5a75\u{1f889}\u{1fefb}\u0b4c\u6782\u036b\uae32\u{1f6d8}\u{1ff16}',
  size: 7901,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let textureView385 = texture11.createView({label: '\u0897\u3d72\u0cc0\u0377\u482b\u33ab\u0e3a\uf859\u{1fb8c}\u{1fdc7}\u17ec'});
try {
computePassEncoder46.setBindGroup(2, bindGroup36, new Uint32Array(3122), 1_034, 0);
} catch {}
try {
buffer154.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData13,
  origin: { x: 9, y: 11 },
  flipY: false,
}, {
  texture: texture237,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let querySet50 = device0.createQuerySet({type: 'occlusion', count: 29});
let externalTexture47 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'});
try {
computePassEncoder25.setBindGroup(1, bindGroup33, new Uint32Array(1610), 78, 0);
} catch {}
try {
computePassEncoder119.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(19);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder51.setIndexBuffer(buffer16, 'uint32', 128, 4_217);
} catch {}
let imageData44 = new ImageData(56, 32);
let buffer284 = device0.createBuffer({
  size: 27106,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder147.setBindGroup(0, bindGroup30);
} catch {}
try {
computePassEncoder165.end();
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer61, 'uint32', 1_296, 773);
} catch {}
let bindGroup212 = device0.createBindGroup({
  label: '\u4a62\u052f\u{1fdc5}\u{1fa04}\u953c',
  layout: bindGroupLayout29,
  entries: [{binding: 166, resource: textureView266}],
});
let buffer285 = device0.createBuffer({size: 2946, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture385 = device0.createTexture({
  size: [161, 1, 1],
  mipLevelCount: 8,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder114.setBindGroup(3, bindGroup35, new Uint32Array(653), 51, 0);
} catch {}
try {
renderPassEncoder45.setBindGroup(3, bindGroup208, new Uint32Array(3559), 83, 0);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(6, buffer91, 4_368, 2_719);
} catch {}
let texture386 = device0.createTexture({
  label: '\u043b\ue754\u{1fd81}\ue9d7\u8717\u{1f6b3}\u7141\ud9ea\u09ab',
  size: {width: 161, height: 1, depthOrArrayLayers: 15},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder228 = commandEncoder199.beginComputePass({});
try {
computePassEncoder25.setBindGroup(0, bindGroup158);
} catch {}
try {
computePassEncoder154.setBindGroup(2, bindGroup128, new Uint32Array(361), 97, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(1, bindGroup40, new Uint32Array(3809), 708, 0);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
let buffer286 = device0.createBuffer({
  label: '\u6e14\u01f4\u{1fb16}\u02e4\u4946\u0bbc',
  size: 7647,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView386 = texture383.createView({label: '\u{1fa3d}\u{1fdfc}\u12bb\u646f\ufe62\ufaa0\u2824\u1817\u0c8b\u7bd9'});
let textureView387 = texture255.createView({baseArrayLayer: 0});
try {
computePassEncoder24.setBindGroup(2, bindGroup13);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup23, new Uint32Array(3005), 752, 0);
} catch {}
try {
gpuCanvasContext14.unconfigure();
} catch {}
let externalTexture48 = device0.importExternalTexture({label: '\u{1fb4a}\u{1f754}\u0106\u207d\u0262\u0edc', source: videoFrame23});
try {
{ clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroups(4); };
} catch {}
try {
computePassEncoder37.end();
} catch {}
try {
commandEncoder47.copyBufferToTexture({
  /* bytesInLastRow: 786 widthInBlocks: 393 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 952 */
  offset: 952,
  bytesPerRow: 12544,
  rowsPerImage: 79,
  buffer: buffer252,
}, {
  texture: texture286,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 393, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder83.popDebugGroup();
} catch {}
let bindGroup213 = device0.createBindGroup({
  label: '\u0a5b\u294b\u{1f9fb}\u019f\u0cda\ud8bf\u0ed4\uadf1\u0019\u083f',
  layout: bindGroupLayout6,
  entries: [
    {binding: 525, resource: {buffer: buffer80, offset: 1280}},
    {binding: 132, resource: {buffer: buffer42, offset: 512}},
    {binding: 130, resource: {buffer: buffer29, offset: 1280}},
    {binding: 216, resource: sampler22},
    {binding: 87, resource: sampler58},
    {binding: 158, resource: textureView28},
    {binding: 35, resource: textureView1},
    {binding: 59, resource: textureView123},
    {binding: 280, resource: sampler116},
    {binding: 45, resource: sampler137},
    {binding: 104, resource: textureView58},
    {binding: 128, resource: {buffer: buffer24, offset: 2304, size: 2711}},
    {binding: 146, resource: {buffer: buffer42, offset: 1792}},
    {binding: 137, resource: {buffer: buffer97, offset: 512, size: 1818}},
    {binding: 76, resource: {buffer: buffer137, offset: 0, size: 991}},
    {binding: 388, resource: textureView178},
    {binding: 81, resource: textureView100},
    {binding: 0, resource: sampler174},
    {binding: 51, resource: {buffer: buffer163, offset: 0}},
    {binding: 140, resource: textureView149},
    {binding: 154, resource: sampler110},
    {binding: 134, resource: externalTexture22},
    {binding: 309, resource: {buffer: buffer205, offset: 512, size: 580}},
    {binding: 65, resource: textureView266},
    {binding: 381, resource: {buffer: buffer286, offset: 768, size: 3512}},
    {binding: 413, resource: textureView99},
    {binding: 58, resource: textureView60},
    {binding: 119, resource: externalTexture45},
    {binding: 191, resource: sampler28},
    {binding: 44, resource: sampler85},
    {binding: 22, resource: {buffer: buffer10, offset: 0, size: 1625}},
    {binding: 160, resource: sampler34},
    {binding: 90, resource: externalTexture11},
    {binding: 114, resource: textureView303},
    {binding: 133, resource: sampler176},
    {binding: 66, resource: textureView255},
    {binding: 64, resource: {buffer: buffer61, offset: 2304, size: 4408}},
    {binding: 201, resource: textureView68},
    {binding: 19, resource: textureView284},
    {binding: 193, resource: sampler142},
    {binding: 56, resource: externalTexture0},
    {binding: 420, resource: sampler194},
    {binding: 84, resource: externalTexture11},
    {binding: 98, resource: {buffer: buffer30, offset: 768, size: 35}},
    {binding: 29, resource: textureView110},
    {binding: 68, resource: sampler109},
    {binding: 75, resource: textureView366},
    {binding: 177, resource: sampler89},
    {binding: 67, resource: externalTexture45},
    {binding: 153, resource: textureView3},
    {binding: 46, resource: textureView123},
    {binding: 61, resource: {buffer: buffer277, offset: 0}},
    {binding: 217, resource: textureView55},
    {binding: 307, resource: {buffer: buffer62, offset: 2048}},
    {binding: 21, resource: {buffer: buffer172, offset: 2304, size: 11148}},
    {binding: 8, resource: sampler163},
    {binding: 107, resource: {buffer: buffer152, offset: 5376, size: 5885}},
    {binding: 18, resource: sampler156},
    {binding: 20, resource: {buffer: buffer19, offset: 256, size: 846}},
    {binding: 384, resource: {buffer: buffer177, offset: 1280, size: 676}},
    {binding: 136, resource: textureView197},
    {binding: 161, resource: {buffer: buffer89, offset: 5632, size: 3730}},
  ],
});
let commandBuffer6 = commandEncoder47.finish();
let texture387 = device0.createTexture({
  label: '\u7694\uda1e\u{1f859}\u0371\u0a72',
  size: [104, 80, 15],
  mipLevelCount: 2,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView388 = texture226.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 11});
try {
computePassEncoder140.setBindGroup(0, bindGroup27, new Uint32Array(212), 36, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder140); computePassEncoder140.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder66.setPipeline(pipeline10);
} catch {}
try {
device0.queue.writeBuffer(buffer94, 1164, new DataView(new ArrayBuffer(360)));
} catch {}
let promise37 = device0.queue.onSubmittedWorkDone();
let textureView389 = texture314.createView({dimension: '2d-array'});
try {
computePassEncoder97.setBindGroup(1, bindGroup106);
} catch {}
try {
computePassEncoder46.setBindGroup(1, bindGroup50, new Uint32Array(2868), 804, 0);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer9, 'uint32', 208, 601);
} catch {}
try {
buffer277.unmap();
} catch {}
let promise38 = device0.queue.onSubmittedWorkDone();
let commandEncoder262 = device0.createCommandEncoder({});
let textureView390 = texture200.createView({});
let computePassEncoder229 = commandEncoder262.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder140); computePassEncoder140.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder46.setBindGroup(2, bindGroup149);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle26, renderBundle49, renderBundle17, renderBundle26]);
} catch {}
try {
renderPassEncoder53.setIndexBuffer(buffer84, 'uint32', 19_348, 1_085);
} catch {}
let arrayBuffer32 = buffer71.getMappedRange(24, 0);
try {
buffer209.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
let bindGroup214 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 71, resource: textureView228},
    {binding: 496, resource: {buffer: buffer184, offset: 512, size: 288}},
    {binding: 13, resource: {buffer: buffer282, offset: 0}},
    {binding: 248, resource: textureView81},
    {binding: 162, resource: textureView99},
  ],
});
try {
computePassEncoder152.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup149, new Uint32Array(416), 70, 0);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer212, 'uint32', 1_224, 1_356);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline1);
} catch {}
try {
  await promise37;
} catch {}
let texture388 = device0.createTexture({
  size: [322, 2, 31],
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler212 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 36.91,
  lodMaxClamp: 84.45,
});
try {
computePassEncoder190.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle29, renderBundle27]);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let texture389 = device0.createTexture({
  label: '\u{1fc8c}\ua4e5\u21e5',
  size: [55],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler213 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 30.71,
  lodMaxClamp: 98.99,
  compare: 'less-equal',
  maxAnisotropy: 9,
});
try {
{ clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroupsIndirect(buffer279, 900); };
} catch {}
try {
computePassEncoder218.end();
} catch {}
try {
computePassEncoder140.end();
} catch {}
try {
computePassEncoder132.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer255, 'uint16', 6, 1_209);
} catch {}
try {
  await promise38;
} catch {}
let bindGroup215 = device0.createBindGroup({
  layout: bindGroupLayout43,
  entries: [{binding: 511, resource: sampler22}, {binding: 9, resource: textureView314}],
});
let computePassEncoder230 = commandEncoder260.beginComputePass({});
let renderPassEncoder54 = commandEncoder171.beginRenderPass({
  colorAttachments: [{view: textureView322, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 160067004,
});
try {
computePassEncoder114.setBindGroup(1, bindGroup22, new Uint32Array(583), 57, 0);
} catch {}
try {
renderPassEncoder54.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(3, buffer184, 260);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 2516, new Float32Array(22731), 1364, 52);
} catch {}
let texture390 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture391 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 125},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder224.setBindGroup(3, bindGroup180, new Uint32Array(2437), 1_435, 0);
} catch {}
try {
renderPassEncoder41.end();
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle3, renderBundle7]);
} catch {}
try {
renderPassEncoder53.setVertexBuffer(4, buffer180, 2_076, 714);
} catch {}
try {
commandEncoder200.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5448 */
  offset: 5448,
  bytesPerRow: 10240,
  buffer: buffer240,
}, {
  texture: texture242,
  mipLevel: 0,
  origin: {x: 6, y: 3, z: 6},
  aspect: 'all',
}, {width: 10, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture182,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(123).fill(74), /* required buffer size: 123 */
{offset: 123, rowsPerImage: 15}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer287 = device0.createBuffer({size: 1946, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandBuffer7 = commandEncoder200.finish({});
let texture392 = device0.createTexture({
  size: [26, 20, 7],
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder144.setBindGroup(3, bindGroup208, new Uint32Array(3905), 969, 0);
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); };
} catch {}
let videoFrame62 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'linear'} });
let querySet51 = device0.createQuerySet({type: 'occlusion', count: 202});
let textureView391 = texture163.createView({});
let externalTexture49 = device0.importExternalTexture({source: videoFrame34});
try {
computePassEncoder181.setBindGroup(0, bindGroup174, new Uint32Array(407), 30, 0);
} catch {}
try {
computePassEncoder133.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder38.setBindGroup(2, bindGroup88);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer205, 'uint32', 904, 69);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline1);
} catch {}
let commandEncoder263 = device0.createCommandEncoder({});
let querySet52 = device0.createQuerySet({type: 'occlusion', count: 349});
let textureView392 = texture199.createView({label: '\u098e\u{1f677}', dimension: '2d', baseArrayLayer: 6});
let computePassEncoder231 = commandEncoder263.beginComputePass();
try {
computePassEncoder162.setPipeline(pipeline5);
} catch {}
let arrayBuffer33 = buffer90.getMappedRange(8512, 8);
let bindGroup216 = device0.createBindGroup({
  layout: bindGroupLayout43,
  entries: [{binding: 9, resource: textureView314}, {binding: 511, resource: sampler33}],
});
try {
computePassEncoder127.setBindGroup(0, bindGroup95);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup158, new Uint32Array(401), 20, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(2, buffer21, 0, 1_010);
} catch {}
try {
device0.queue.submit([commandBuffer7]);
} catch {}
let videoFrame63 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'pq'} });
let bindGroupLayout44 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 223,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 464,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 129,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false },
    },
  ],
});
let textureView393 = texture371.createView({});
try {
computePassEncoder43.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder47.setBindGroup(2, bindGroup72);
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle31, renderBundle42, renderBundle31, renderBundle27]);
} catch {}
try {
  await shaderModule9.getCompilationInfo();
} catch {}
try {
device0.queue.writeBuffer(buffer165, 1288, new DataView(new ArrayBuffer(13009)), 2735, 1796);
} catch {}
try {
computePassEncoder105.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder46.setBindGroup(2, bindGroup177);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer9, 'uint32', 1_752, 1_159);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 1}
*/
{
  source: imageData7,
  origin: { x: 2, y: 2 },
  flipY: true,
}, {
  texture: texture66,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup217 = device0.createBindGroup({
  label: '\u0a85\u0f3f\u0c2d\u{1fec5}\u{1fb19}\ucb32\u1cba\u0934',
  layout: bindGroupLayout39,
  entries: [
    {binding: 114, resource: textureView357},
    {binding: 69, resource: textureView109},
    {binding: 130, resource: textureView350},
    {binding: 61, resource: externalTexture35},
    {binding: 432, resource: textureView128},
    {binding: 193, resource: {buffer: buffer122, offset: 256}},
    {binding: 3, resource: {buffer: buffer98, offset: 768, size: 1048}},
    {binding: 246, resource: sampler206},
    {binding: 175, resource: textureView53},
    {binding: 274, resource: {buffer: buffer11, offset: 0, size: 456}},
    {binding: 16, resource: textureView109},
    {binding: 26, resource: sampler158},
    {binding: 137, resource: textureView326},
    {binding: 47, resource: textureView246},
    {binding: 7, resource: {buffer: buffer205, offset: 256, size: 244}},
    {binding: 36, resource: {buffer: buffer150, offset: 0}},
    {binding: 60, resource: textureView154},
    {binding: 31, resource: externalTexture5},
    {binding: 13, resource: textureView139},
    {binding: 77, resource: sampler116},
    {binding: 165, resource: textureView393},
    {binding: 37, resource: textureView75},
    {binding: 127, resource: {buffer: buffer40, offset: 1024, size: 1024}},
    {binding: 32, resource: sampler170},
    {binding: 103, resource: {buffer: buffer209, offset: 256, size: 528}},
    {binding: 143, resource: textureView333},
    {binding: 33, resource: {buffer: buffer17, offset: 768, size: 516}},
    {binding: 55, resource: {buffer: buffer207, offset: 0}},
    {binding: 304, resource: textureView10},
    {binding: 50, resource: textureView223},
    {binding: 523, resource: {buffer: buffer157, offset: 768, size: 360}},
    {binding: 41, resource: textureView333},
    {binding: 151, resource: textureView98},
    {binding: 167, resource: externalTexture18},
    {binding: 6, resource: externalTexture44},
    {binding: 174, resource: textureView353},
    {binding: 44, resource: {buffer: buffer282, offset: 0}},
    {binding: 343, resource: {buffer: buffer152, offset: 8448, size: 6920}},
    {binding: 113, resource: textureView282},
    {binding: 115, resource: externalTexture35},
    {binding: 100, resource: sampler82},
    {binding: 53, resource: {buffer: buffer119, offset: 1536, size: 390}},
    {binding: 18, resource: textureView200},
    {binding: 88, resource: {buffer: buffer29, offset: 3072}},
    {binding: 369, resource: {buffer: buffer243, offset: 1536, size: 223}},
    {binding: 172, resource: {buffer: buffer152, offset: 22784, size: 1236}},
    {binding: 240, resource: sampler141},
    {binding: 83, resource: {buffer: buffer258, offset: 4608, size: 8304}},
    {binding: 12, resource: sampler74},
    {binding: 110, resource: {buffer: buffer17, offset: 2816, size: 307}},
  ],
});
let textureView394 = texture287.createView({});
try {
computePassEncoder39.setBindGroup(2, bindGroup205);
} catch {}
try {
computePassEncoder221.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder52.setBindGroup(1, bindGroup115, new Uint32Array(2495), 236, 0);
} catch {}
try {
renderPassEncoder43.setViewport(48.5882889806486, 35.1423133051364, 0.668975756477888, 0.129131294505001, 0.4164280305393988, 0.521662641468259);
} catch {}
let texture393 = device0.createTexture({
  label: '\u6bdf\ueb8e\u538e\u{1fc0c}\ud913\u18c9\u5ee3\uda35\u0cd2\u7114\u3658',
  size: {width: 55, height: 8, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder227.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder43.setBindGroup(2, bindGroup31, new Uint32Array(32), 10, 0);
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle42, renderBundle44, renderBundle31, renderBundle42, renderBundle27, renderBundle31]);
} catch {}
try {
renderPassEncoder44.setVertexBuffer(4, buffer61);
} catch {}
let arrayBuffer34 = buffer90.getMappedRange(8392, 4);
let bindGroup218 = device0.createBindGroup({layout: bindGroupLayout34, entries: [{binding: 278, resource: textureView175}]});
try {
renderPassEncoder30.setStencilReference(626);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline3);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: videoFrame24,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture316,
  mipLevel: 0,
  origin: {x: 11, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let videoFrame64 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte432', transfer: 'smpte240m'} });
let shaderModule13 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

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

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

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

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

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

@group(0) @binding(7) var tex112: texture_2d<u32>;

@group(0) @binding(29) var st32: texture_storage_3d<rgba16uint, write>;

@group(0) @binding(124) var st33: texture_storage_2d_array<r32float, read_write>;

@group(0) @binding(136) var st34: texture_storage_3d<rg32sint, write>;

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

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

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

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

struct VertexOutput13 {
  @location(6) f39: vec2f,
  @location(3) f40: vec2u,
  @builtin(position) f41: vec4f,
}

override override31: f32;

fn fn0() -> vec4h {
  var out: vec4h;
  out *= vec4h(f16(dot(vec4u(unconst_u32(147), unconst_u32(232), unconst_u32(101), unconst_u32(2)), vec4u(unconst_u32(352), unconst_u32(1), unconst_u32(415), unconst_u32(250)))));
  out *= vec4h(f16(dot(vec4u(unconst_u32(114), unconst_u32(95), unconst_u32(40), unconst_u32(10)), vec4u(unconst_u32(323), unconst_u32(2), unconst_u32(158), unconst_u32(687)))));
  var vf168: u32 = countLeadingZeros(u32(unconst_u32(81)));
  let vf169: i32 = extractBits(bitcast<i32>(min(countOneBits(u32(unconst_u32(90))), u32(unconst_u32(346)))), u32(unconst_u32(224)), u32(unconst_u32(67)));
  let vf170: vec2h = refract(vec2h(unconst_f16(929.4), unconst_f16(10044.8)), vec2h(unconst_f16(2706.6), unconst_f16(119.9)), f16(unconst_f16(28200.8)));
  var vf171: u32 = min(u32(unconst_u32(40)), vf168);
  var vf172: vec2h = fma(vec2h(unconst_f16(23915.2), unconst_f16(13161.8)), vec2h(unconst_f16(4881.4), unconst_f16(5611.9)), vec2h(unconst_f16(46780.0), unconst_f16(4967.1)));
  let ptr200: ptr<function, u32> = &vf171;
  let ptr201: ptr<function, vec2h> = &vf172;
  var vf173: vec2f = log2(vec2f(unconst_f32(0.06500), unconst_f32(0.09572)));
  out -= vec4h(f16(min(u32(unconst_u32(15)), bitcast<u32>(override31))));
  let ptr202: ptr<function, u32> = &(*ptr200);
  vf172 -= bitcast<vec2h>(vf168);
  var vf174: f16 = fract(cosh(vec3h(unconst_f16(15635.1), unconst_f16(39473.1), unconst_f16(4976.8)))[0]);
  var vf175: vec2f = unpack2x16snorm(u32(unconst_u32(105)));
  let vf176: f32 = vf175[pack2x16snorm(log2(vec2f(unconst_f32(0.1385), unconst_f32(0.1261))))];
  return out;
  _ = override31;
}

fn fn1(a0: VertexOutput13) -> array<array<array<f16, 1>, 29>, 1> {
  var out: array<array<array<f16, 1>, 29>, 1>;
  fn0();
  out[u32(unconst_u32(52))][u32(unconst_u32(91))][u32(unconst_u32(231))] *= f16(a0.f41[u32(unconst_u32(151))]);
  out[0][28][u32(unconst_u32(150))] = vec3h(select(vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true)), vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false)), vec3<bool>(inverseSqrt(vec4f(unconst_f32(-0.3684), unconst_f32(-0.1603), unconst_f32(0.2041), unconst_f32(0.5274))).zzw))).r;
  fn0();
  var vf177: vec3h = floor(vec3h(unconst_f16(3316.3), unconst_f16(3734.6), unconst_f16(4043.7)));
  let vf178: f32 = a0.f41[u32(unconst_u32(57))];
  vf177 += vec3h(vf177[u32(unconst_u32(264))]);
  out[pack4x8unorm(a0.f41)][28][u32(unconst_u32(58))] *= f16(saturate(vec4f(unconst_f32(0.08435), unconst_f32(0.3212), unconst_f32(0.2982), unconst_f32(0.08334))).z);
  let vf179: i32 = max(i32(unconst_i32(84)), i32(unconst_i32(870)));
  vf177 = vec3h(a0.f40.grr);
  out[u32(unconst_u32(104))][u32(unconst_u32(272))][u32(unconst_u32(102))] -= cosh(vec4h(inverseSqrt(vec4f(unconst_f32(0.1575), unconst_f32(0.06248), unconst_f32(-0.08666), unconst_f32(-0.00374)))).z);
  out[u32(unconst_u32(325))][u32(unconst_u32(11))][u32(unconst_u32(70))] += f16(pack4x8unorm(vec4f(unconst_f32(0.6344), unconst_f32(0.08512), unconst_f32(0.00589), unconst_f32(-0.3216))));
  out[u32(unconst_u32(190))][u32(unconst_u32(49))][u32(unconst_u32(74))] = f16(a0.f39[0]);
  fn0();
  var vf180 = fn0();
  let vf181: vec4f = a0.f41;
  return out;
  _ = override31;
}

var<workgroup> vw35: f16;

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

var<workgroup> vw37: vec4u;

var<workgroup> vw38: mat2x4f;

var<workgroup> vw39: mat4x3h;

var<workgroup> vw40: VertexOutput13;

var<workgroup> vw41: mat4x3h;

var<workgroup> vw42: atomic<i32>;

@vertex
fn vertex14() -> VertexOutput13 {
  var out: VertexOutput13;
  fn0();
  out.f39 = bitcast<vec2f>(unpack4xU8(u32(unconst_u32(90))).gb);
  out.f39 *= vec2f(sign(f32(unconst_f32(0.00014))));
  var vf182 = fn1(VertexOutput13(cross(vec3f(unconst_f32(0.04217), unconst_f32(0.04180), unconst_f32(0.00013)), vec3f(unconst_f32(0.07970), unconst_f32(0.1009), unconst_f32(0.2566))).xz, bitcast<vec2u>(cross(vec3f(unconst_f32(0.04217), unconst_f32(0.04180), unconst_f32(0.00013)), vec3f(unconst_f32(0.07970), unconst_f32(0.1009), unconst_f32(0.2566))).rr), cross(vec3f(unconst_f32(0.04217), unconst_f32(0.04180), unconst_f32(0.00013)), vec3f(unconst_f32(0.07970), unconst_f32(0.1009), unconst_f32(0.2566))).bgrg));
  vf182[u32(unconst_u32(267))][u32(vf182[u32(unconst_u32(173))][28][0])][u32(unconst_u32(114))] = vf182[u32(unconst_u32(100))][28][0];
  return out;
  _ = override31;
}

@compute @workgroup_size(1, 1, 1)
fn compute12(@builtin(local_invocation_id) a0: vec3u) {
  var vf183 = fn0();
  fn1(VertexOutput13(vec2f(f32((*&vw35))), vec2u(u32((*&vw35))), vec4f(f32((*&vw35)))));
  fn0();
  var vf184 = fn0();
  let ptr203: ptr<workgroup, atomic<i32>> = &(*&vw36)[u32(unconst_u32(92))];
  var vf185 = fn1(VertexOutput13(vec2f(f32(vf184[u32(unconst_u32(129))])), vec2u(u32(vf184[u32(unconst_u32(129))])), vec4f(f32(vf184[u32(unconst_u32(129))]))));
  let ptr204: ptr<workgroup, vec4u> = &(*&vw37);
  let vf186: f32 = override31;
  atomicCompareExchangeWeak(&vw36[u32(unconst_u32(65))], unconst_i32(111), unconst_i32(111));
  _ = override31;
}`,
  sourceMap: {},
  hints: {},
});
try {
renderPassEncoder17.setVertexBuffer(1, buffer220, 16, 159);
} catch {}
let promise39 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame4,
  origin: { x: 28, y: 0 },
  flipY: true,
}, {
  texture: texture152,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 3, depthOrArrayLayers: 0});
} catch {}
let texture394 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 1},
  format: 'r8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView395 = texture106.createView({label: '\u0866\u3942\u0ee9', dimension: '2d', format: 'r16sint'});
try {
renderPassEncoder38.setBindGroup(3, bindGroup23);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup129, new Uint32Array(4978), 2_305, 0);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(5, undefined);
} catch {}
let arrayBuffer35 = buffer71.getMappedRange(56, 0);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 55, height: 8, depthOrArrayLayers: 312}
*/
{
  source: offscreenCanvas8,
  origin: { x: 0, y: 7 },
  flipY: false,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 29},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let videoFrame65 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt2020', transfer: 'bt709'} });
let buffer288 = device0.createBuffer({size: 3990, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let textureView396 = texture238.createView({mipLevelCount: 1});
let externalTexture50 = device0.importExternalTexture({source: videoFrame53});
try {
computePassEncoder38.setBindGroup(1, bindGroup38);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline3);
} catch {}
try {
buffer88.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 645, height: 4, depthOrArrayLayers: 62}
*/
{
  source: videoFrame62,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture218,
  mipLevel: 1,
  origin: {x: 59, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup219 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 34, resource: {buffer: buffer240, offset: 2048, size: 1760}},
    {binding: 347, resource: textureView175},
  ],
});
let externalTexture51 = device0.importExternalTexture({source: videoFrame59});
try {
renderPassEncoder18.setBindGroup(2, bindGroup146, new Uint32Array(4019), 1_894, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer8, 'uint16', 1_780, 1_945);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3, buffer24, 0, 5_999);
} catch {}
let textureView397 = texture327.createView({dimension: '2d', baseArrayLayer: 2});
try {
computePassEncoder216.setBindGroup(3, bindGroup29, new Uint32Array(794), 26, 0);
} catch {}
try {
computePassEncoder226.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup113);
} catch {}
try {
renderPassEncoder29.setStencilReference(702);
} catch {}
let arrayBuffer36 = buffer211.getMappedRange(136, 24);
let buffer289 = device0.createBuffer({size: 6367, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder184.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder38.setBindGroup(2, bindGroup29);
} catch {}
try {
renderPassEncoder38.setBindGroup(3, bindGroup211, new Uint32Array(3167), 1_114, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer179, 'uint32', 7_356, 2_679);
} catch {}
await gc();
let bindGroupLayout45 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 49,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 148, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 54,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 91, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 83,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
try {
computePassEncoder198.setBindGroup(0, bindGroup52);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(5, buffer83);
} catch {}
try {
gpuCanvasContext10.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'display-p3'});
} catch {}
let texture395 = device0.createTexture({
  size: {width: 13, height: 2, depthOrArrayLayers: 9},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder52 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder132.setBindGroup(2, bindGroup66);
} catch {}
try {
computePassEncoder111.setBindGroup(3, bindGroup80, new Uint32Array(10000), 502, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup208, new Uint32Array(3084), 316, 0);
} catch {}
try {
renderBundleEncoder52.setIndexBuffer(buffer260, 'uint16', 1_584, 208);
} catch {}
try {
buffer151.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture100,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(6_822).fill(72), /* required buffer size: 6_822 */
{offset: 166, bytesPerRow: 26, rowsPerImage: 64}, {width: 0, height: 0, depthOrArrayLayers: 5});
} catch {}
try {
computePassEncoder18.setBindGroup(3, bindGroup60, new Uint32Array(832), 123, 0);
} catch {}
try {
computePassEncoder217.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer17, 0, 938);
} catch {}
try {
renderBundleEncoder52.setBindGroup(3, bindGroup211, new Uint32Array(1472), 89, 0);
} catch {}
try {
renderBundleEncoder52.setIndexBuffer(buffer119, 'uint32', 2_248, 614);
} catch {}
try {
renderPassEncoder36.insertDebugMarker('\u0dba');
} catch {}
let pipelineLayout22 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture396 = device0.createTexture({
  size: [104, 80, 1],
  mipLevelCount: 4,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView398 = texture382.createView({label: '\u{1fdae}\u00f8\ua734\udf65\u0cd6', aspect: 'all'});
let renderBundle52 = renderBundleEncoder52.finish();
try {
renderPassEncoder9.setBindGroup(3, bindGroup4);
} catch {}
let promise40 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); };
} catch {}
let texture397 = device0.createTexture({
  size: [2, 2, 27],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler214 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 33.25,
  lodMaxClamp: 65.93,
  compare: 'not-equal',
  maxAnisotropy: 7,
});
try {
computePassEncoder26.setBindGroup(1, bindGroup19, []);
} catch {}
try {
computePassEncoder69.setBindGroup(1, bindGroup106, new Uint32Array(1175), 374, 0);
} catch {}
try {
computePassEncoder122.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup52, new Uint32Array(3980), 1_623, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer30, 'uint16', 48, 127);
} catch {}
try {
gpuCanvasContext13.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
document.body.append(canvas5);
let buffer290 = device0.createBuffer({
  size: 2647,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
await gc();
let bindGroup220 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 348, resource: textureView69}, {binding: 90, resource: externalTexture28}],
});
let texture398 = device0.createTexture({size: {width: 13}, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST});
let externalTexture52 = device0.importExternalTexture({label: '\u09a8\u6410\u{1f8f1}\u7dd8\u91e2\ufa22\u07e7\u114f\u0aca\u0265\u08b4', source: videoFrame28});
try {
{ clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder57.setPipeline(pipeline7);
} catch {}
try {
gpuCanvasContext13.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
await gc();
let textureView399 = texture200.createView({});
try {
computePassEncoder153.setBindGroup(0, bindGroup49, new Uint32Array(369), 10, 0);
} catch {}
try {
computePassEncoder231.setPipeline(pipeline2);
} catch {}
let arrayBuffer37 = buffer211.getMappedRange(160, 88);
document.body.append(img2);
let buffer291 = device0.createBuffer({size: 21815, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder186.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup198, new Uint32Array(36), 2, 0);
} catch {}
try {
renderPassEncoder51.executeBundles([renderBundle29]);
} catch {}
let buffer292 = device0.createBuffer({
  label: '\u{1fc8d}\ucc97\u{1fc74}\u0025\u3de5\u3106',
  size: 20613,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView400 = texture16.createView({});
try {
computePassEncoder94.setBindGroup(3, bindGroup171);
} catch {}
try {
computePassEncoder180.setBindGroup(2, bindGroup67, new Uint32Array(1650), 486, 0);
} catch {}
try {
computePassEncoder161.end();
} catch {}
try {
computePassEncoder61.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup106, new Uint32Array(571), 22, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer35, 'uint32', 540, 852);
} catch {}
let bindGroupLayout46 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 102,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 109,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 152,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 395,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let texture399 = device0.createTexture({
  label: '\u0ab8\u4b5e',
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder229.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder46.setBindGroup(1, bindGroup100);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let bindGroup221 = device0.createBindGroup({
  label: '\u1197\u{1f7a6}\ud4d3\u8fe8\u0bc7\u0ba8\uc451\u9ec1',
  layout: bindGroupLayout10,
  entries: [
    {binding: 216, resource: {buffer: buffer19, offset: 1024, size: 2116}},
    {binding: 408, resource: textureView73},
    {binding: 479, resource: externalTexture49},
    {binding: 33, resource: textureView287},
    {binding: 328, resource: textureView232},
    {binding: 2, resource: textureView76},
    {binding: 49, resource: {buffer: buffer77, offset: 256, size: 1780}},
    {binding: 34, resource: sampler11},
    {binding: 67, resource: textureView108},
    {binding: 68, resource: {buffer: buffer158, offset: 1024, size: 3384}},
    {binding: 29, resource: sampler97},
    {binding: 117, resource: {buffer: buffer140, offset: 0, size: 687}},
    {binding: 232, resource: {buffer: buffer5, offset: 1536}},
    {binding: 712, resource: {buffer: buffer137, offset: 1536, size: 504}},
    {binding: 209, resource: textureView384},
    {binding: 38, resource: sampler29},
    {binding: 20, resource: externalTexture24},
    {binding: 135, resource: externalTexture6},
    {binding: 142, resource: textureView269},
    {binding: 36, resource: sampler111},
    {binding: 125, resource: textureView110},
    {binding: 161, resource: textureView290},
    {binding: 118, resource: textureView110},
    {binding: 348, resource: textureView10},
    {binding: 195, resource: textureView10},
    {binding: 228, resource: {buffer: buffer62, offset: 4608}},
    {binding: 8, resource: textureView61},
    {binding: 330, resource: {buffer: buffer253, offset: 2048, size: 524}},
    {binding: 697, resource: {buffer: buffer166, offset: 1280}},
    {binding: 112, resource: textureView270},
    {binding: 318, resource: {buffer: buffer163, offset: 0, size: 216}},
    {binding: 384, resource: externalTexture19},
    {binding: 65, resource: textureView1},
    {binding: 62, resource: sampler118},
    {binding: 61, resource: textureView47},
    {binding: 99, resource: {buffer: buffer260, offset: 4864, size: 2553}},
    {binding: 162, resource: textureView134},
    {binding: 95, resource: sampler79},
    {binding: 5, resource: textureView84},
    {binding: 55, resource: {buffer: buffer239, offset: 0, size: 64}},
    {binding: 141, resource: textureView75},
    {binding: 15, resource: textureView109},
    {binding: 47, resource: sampler28},
    {binding: 54, resource: externalTexture32},
  ],
});
let computePassEncoder232 = commandEncoder194.beginComputePass({});
try {
computePassEncoder232.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle38, renderBundle3, renderBundle18, renderBundle1, renderBundle2, renderBundle38, renderBundle1, renderBundle17]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer159);
} catch {}
let bindGroupLayout47 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 38,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 156,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup222 = device0.createBindGroup({layout: bindGroupLayout28, entries: [{binding: 423, resource: textureView284}]});
let textureView401 = texture207.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 6});
try {
computePassEncoder210.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder44.setBindGroup(0, bindGroup119);
} catch {}
try {
renderPassEncoder45.setBindGroup(3, bindGroup195, new Uint32Array(3096), 722, 0);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer74, 'uint32', 12, 368);
} catch {}
try {
computePassEncoder102.pushDebugGroup('\uc61c');
} catch {}
try {
device0.queue.writeBuffer(buffer291, 2784, new Int16Array(3043), 179, 416);
} catch {}
let bindGroupLayout48 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 119,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 88,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let texture400 = device0.createTexture({
  size: [322, 2, 1],
  mipLevelCount: 4,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView402 = texture164.createView({dimension: '2d-array'});
let renderBundleEncoder53 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder195.setBindGroup(1, bindGroup15, new Uint32Array(2179), 12, 0);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle28]);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer72, 'uint16', 142, 8_312);
} catch {}
document.body.prepend(img0);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let externalTexture53 = device0.importExternalTexture({source: videoFrame52, colorSpace: 'display-p3'});
try {
computePassEncoder146.setBindGroup(0, bindGroup92, new Uint32Array(4774), 1_234, 0);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(1, buffer238, 608, 6_183);
} catch {}
try {
if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); };
} catch {}
let bindGroup223 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 293, resource: textureView100}]});
let texture401 = device0.createTexture({
  label: '\ud87b\u72ff\u{1f655}\u7eea\u0b2a',
  size: [13, 10, 33],
  sampleCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView403 = texture219.createView({});
let sampler215 = device0.createSampler({
  label: '\uacea\u{1fd38}\u5e42\u38b2\u{1fbe2}\u{1fc98}\u88fd\u1f3c',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 59.47,
  lodMaxClamp: 87.81,
  maxAnisotropy: 8,
});
try {
computePassEncoder38.setBindGroup(3, bindGroup149, new Uint32Array(1457), 170, 0);
} catch {}
try {
renderBundleEncoder53.setBindGroup(2, bindGroup174, new Uint32Array(2235), 688, 0);
} catch {}
try {
buffer205.unmap();
} catch {}
try {
computePassEncoder102.popDebugGroup();
} catch {}
let bindGroup224 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 37, resource: textureView17},
    {binding: 285, resource: {buffer: buffer145, offset: 256, size: 4791}},
  ],
});
let textureView404 = texture364.createView({label: '\u85a7\u0487\u{1faa7}\u0725\uf14a\ub344\u055d\ue7ce\u3b89', dimension: '2d'});
let renderBundle53 = renderBundleEncoder53.finish();
try {
computePassEncoder52.setBindGroup(0, bindGroup145, new Uint32Array(1961), 146, 0);
} catch {}
try {
renderPassEncoder47.beginOcclusionQuery(14);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 102}
*/
{
  source: canvas6,
  origin: { x: 59, y: 25 },
  flipY: true,
}, {
  texture: texture253,
  mipLevel: 0,
  origin: {x: 34, y: 0, z: 20},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup225 = device0.createBindGroup({
  label: '\u01ad\u0665',
  layout: bindGroupLayout22,
  entries: [
    {binding: 92, resource: textureView195},
    {binding: 46, resource: textureView298},
    {binding: 440, resource: sampler184},
    {binding: 594, resource: textureView3},
    {binding: 5, resource: textureView238},
  ],
});
let texture402 = device0.createTexture({
  size: [170, 170, 1],
  mipLevelCount: 4,
  format: 'astc-5x5-unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler216 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 14.64,
  lodMaxClamp: 32.47,
  maxAnisotropy: 13,
});
try {
computePassEncoder209.setBindGroup(2, bindGroup123);
} catch {}
try {
renderPassEncoder52.setVertexBuffer(3, buffer248);
} catch {}
try {
computePassEncoder137.setBindGroup(1, bindGroup85);
} catch {}
document.body.append(img0);
let buffer293 = device0.createBuffer({
  label: '\u{1f9f0}\u52a3\u0648\ue88b\uf850\u557f\u0893\ua5e0\ubd1a\u941a',
  size: 7843,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let querySet53 = device0.createQuerySet({
  label: '\u{1fa3b}\ua1a2\ue642\u{1f974}\ufd87\u{1feda}\u{1fbd7}\u{1fe74}\u{1fc53}\u2ae4',
  type: 'occlusion',
  count: 396,
});
let textureView405 = texture170.createView({dimension: '2d-array'});
try {
computePassEncoder94.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder47.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer84, 'uint32', 2_124, 3_669);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture142,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(76).fill(150), /* required buffer size: 76 */
{offset: 76, bytesPerRow: 569}, {width: 68, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup226 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 389, resource: textureView181},
    {binding: 177, resource: textureView197},
    {binding: 163, resource: sampler175},
    {binding: 110, resource: textureView135},
    {binding: 185, resource: textureView289},
    {binding: 252, resource: {buffer: buffer284, offset: 2816, size: 2052}},
    {binding: 287, resource: textureView370},
    {binding: 8, resource: textureView37},
    {binding: 88, resource: textureView74},
    {binding: 79, resource: {buffer: buffer83, offset: 2048}},
    {binding: 306, resource: textureView266},
    {binding: 160, resource: textureView356},
    {binding: 70, resource: textureView398},
    {binding: 44, resource: sampler32},
    {binding: 68, resource: {buffer: buffer150, offset: 0}},
    {binding: 523, resource: textureView138},
    {binding: 14, resource: {buffer: buffer221, offset: 0, size: 290}},
    {binding: 47, resource: textureView137},
    {binding: 349, resource: sampler72},
    {binding: 351, resource: {buffer: buffer150, offset: 512}},
    {binding: 190, resource: textureView254},
    {binding: 12, resource: {buffer: buffer225, offset: 1792, size: 3088}},
    {binding: 6, resource: textureView353},
    {binding: 255, resource: {buffer: buffer55, offset: 0, size: 136}},
    {binding: 0, resource: {buffer: buffer205, offset: 0, size: 2548}},
    {binding: 196, resource: textureView151},
    {binding: 143, resource: {buffer: buffer1, offset: 768, size: 446}},
    {binding: 195, resource: textureView223},
  ],
});
let buffer294 = device0.createBuffer({
  label: '\uef43\u04cc\u0a50\ufee9\u07a9\u7cab',
  size: 3673,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder128.setPipeline(pipeline7);
} catch {}
try {
computePassEncoder202.insertDebugMarker('\u09a7');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture238,
  mipLevel: 0,
  origin: {x: 27, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(190).fill(59), /* required buffer size: 190 */
{offset: 190, bytesPerRow: 155}, {width: 29, height: 24, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder192.setBindGroup(0, bindGroup8, new Uint32Array(51), 8, 0);
} catch {}
try {
computePassEncoder207.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer205, 'uint16', 636, 20);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline3);
} catch {}
let bindGroup227 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 148, resource: textureView76}, {binding: 389, resource: textureView123}],
});
try {
computePassEncoder201.setBindGroup(3, bindGroup52, new Uint32Array(827), 11, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup61);
} catch {}
try {
renderPassEncoder28.setBlendConstant({ r: -966.1, g: 318.7, b: -56.35, a: -451.8, });
} catch {}
try {
renderPassEncoder0.setScissorRect(0, 3, 3, 5);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer75, 'uint16', 4_638, 8_546);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture380,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(2_022_090).fill(107), /* required buffer size: 2_022_090 */
{offset: 330, bytesPerRow: 81, rowsPerImage: 40}, {width: 10, height: 0, depthOrArrayLayers: 625});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame20,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture337,
  mipLevel: 0,
  origin: {x: 35, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView406 = texture304.createView({dimension: '1d', aspect: 'all'});
try {
computePassEncoder232.setBindGroup(3, bindGroup57, new Uint32Array(5536), 291, 0);
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); };
} catch {}
let buffer295 = device0.createBuffer({
  size: 17711,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let texture403 = device0.createTexture({
  size: [322, 2, 1],
  mipLevelCount: 4,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder141.setBindGroup(0, bindGroup87, new Uint32Array(2620), 450, 0);
} catch {}
try {
computePassEncoder168.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder43.setViewport(23.86222669197676, 21.136528999970206, 5.583636113833291, 10.989674396852763, 0.444516460379366, 0.4673206162646269);
} catch {}
try {
buffer200.unmap();
} catch {}
let bindGroup228 = device0.createBindGroup({
  layout: bindGroupLayout25,
  entries: [
    {binding: 22, resource: textureView315},
    {binding: 26, resource: {buffer: buffer92, offset: 512, size: 4004}},
  ],
});
try {
computePassEncoder224.setBindGroup(2, bindGroup147);
} catch {}
try {
computePassEncoder230.setPipeline(pipeline10);
} catch {}
let arrayBuffer38 = buffer90.getMappedRange(8328, 0);
document.body.append(canvas3);
let texture404 = device0.createTexture({
  size: [27, 4, 12],
  sampleCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler217 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 96.85,
  lodMaxClamp: 97.80,
  maxAnisotropy: 16,
});
try {
renderPassEncoder30.setVertexBuffer(7, undefined, 718_731_287);
} catch {}
try {
computePassEncoder28.insertDebugMarker('\u{1fbe7}');
} catch {}
let textureView407 = texture206.createView({format: 'rgba16float'});
try {
computePassEncoder229.setBindGroup(2, bindGroup52, new Uint32Array(1186), 260, 0);
} catch {}
try {
renderPassEncoder45.setBindGroup(2, bindGroup200, new Uint32Array(1359), 66, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer33.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture58,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(22_553).fill(216), /* required buffer size: 22_553 */
{offset: 377, bytesPerRow: 84, rowsPerImage: 33}, {width: 0, height: 0, depthOrArrayLayers: 9});
} catch {}
let bindGroupLayout49 = device0.createBindGroupLayout({entries: [{binding: 60, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }}]});
let bindGroup229 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 159, resource: textureView254},
    {binding: 208, resource: textureView296},
    {binding: 31, resource: textureView208},
  ],
});
let sampler218 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 84.27,
  lodMaxClamp: 90.22,
  maxAnisotropy: 17,
});
try {
computePassEncoder212.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer72, 'uint16', 342, 12_732);
} catch {}
try {
renderPassEncoder47.setVertexBuffer(1, buffer212, 4_004);
} catch {}
try {
computePassEncoder226.setBindGroup(0, bindGroup124, new Uint32Array(2087), 510, 0);
} catch {}
try {
computePassEncoder138.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup118, []);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup47, new Uint32Array(440), 84, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer89, 'uint32', 480, 13_548);
} catch {}
document.body.prepend(canvas1);
let externalTexture54 = device0.importExternalTexture({source: videoFrame40});
try {
computePassEncoder131.setBindGroup(1, bindGroup95);
} catch {}
try {
renderPassEncoder37.setBindGroup(3, bindGroup196);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline3);
} catch {}
let textureView408 = texture353.createView({dimension: '2d', format: 'astc-8x8-unorm-srgb', mipLevelCount: 1, baseArrayLayer: 9});
try {
computePassEncoder63.setBindGroup(1, bindGroup48, new Uint32Array(3229), 332, 0);
} catch {}
try {
computePassEncoder82.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer292, 'uint16', 4_394, 1_673);
} catch {}
try {
renderPassEncoder51.setVertexBuffer(4, buffer119, 100, 55);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture134,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 15},
  aspect: 'all',
}, new Uint8Array(31).fill(101), /* required buffer size: 31 */
{offset: 31}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let texture405 = device0.createTexture({
  size: [110, 16, 625],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder215.setBindGroup(2, bindGroup210, []);
} catch {}
try {
buffer33.unmap();
} catch {}
let buffer296 = device0.createBuffer({
  size: 5173,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
try {
computePassEncoder61.setBindGroup(3, bindGroup151);
} catch {}
try {
computePassEncoder30.setPipeline(pipeline10);
} catch {}
let texture406 = device0.createTexture({
  size: {width: 27},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder71.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder54.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, buffer99, 612);
} catch {}
let arrayBuffer39 = buffer217.getMappedRange(112, 8);
try {
device0.queue.writeTexture({
  texture: texture376,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(224).fill(148), /* required buffer size: 224 */
{offset: 224, rowsPerImage: 111}, {width: 81, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise41 = device0.queue.onSubmittedWorkDone();
let offscreenCanvas10 = new OffscreenCanvas(219, 269);
try {
adapter0.label = '\u{1ffef}\u0b56';
} catch {}
let texture407 = device0.createTexture({
  label: '\u23f8\u0c62\u{1f696}\u7917\u08a2\u0acf\u07bd',
  size: [55, 8, 1],
  mipLevelCount: 3,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r16float'],
});
let textureView409 = texture115.createView({});
try {
renderPassEncoder44.setBindGroup(3, bindGroup95);
} catch {}
let buffer297 = device0.createBuffer({size: 37323, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let sampler219 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 1.219,
  lodMaxClamp: 39.47,
  compare: 'always',
});
try {
computePassEncoder68.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder183.setBindGroup(0, bindGroup114, new Uint32Array(2044), 169, 0);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(1, buffer43);
} catch {}
try {
buffer30.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 645, height: 4, depthOrArrayLayers: 1}
*/
{
  source: imageData15,
  origin: { x: 13, y: 5 },
  flipY: false,
}, {
  texture: texture66,
  mipLevel: 0,
  origin: {x: 108, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); };
} catch {}
let bindGroup230 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 159, resource: textureView146},
    {binding: 208, resource: textureView392},
    {binding: 31, resource: textureView403},
  ],
});
let pipelineLayout23 = device0.createPipelineLayout({label: '\u0532\u007e\ua414\u823f\u0daf\u54e5\u{1fc73}\u2666\ua4f2\u{1feef}', bindGroupLayouts: []});
let texture408 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 31},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder210.setBindGroup(3, bindGroup48, new Uint32Array(6219), 836, 0);
} catch {}
try {
computePassEncoder228.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder46.setBindGroup(0, bindGroup40);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup11, new Uint32Array(3124), 753, 0);
} catch {}
try {
adapter0.label = '\ue499\u{1fb57}';
} catch {}
try {
computePassEncoder174.setBindGroup(0, bindGroup59);
} catch {}
try {
computePassEncoder121.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer8, 'uint16', 9_980, 207);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(4, buffer157);
} catch {}
let pipelineLayout24 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture409 = device0.createTexture({size: [1290, 8, 1], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST});
let textureView410 = texture277.createView({aspect: 'stencil-only', baseArrayLayer: 7, arrayLayerCount: 5});
let sampler220 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 97.92,
  lodMaxClamp: 98.51,
});
try {
computePassEncoder211.setBindGroup(2, bindGroup90, new Uint32Array(2578), 622, 0);
} catch {}
try {
computePassEncoder189.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder23.setBlendConstant({ r: -680.7, g: 532.7, b: -477.2, a: 488.5, });
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer30, 'uint16', 690, 254);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let buffer298 = device0.createBuffer({
  size: 16595,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder62.setBindGroup(1, bindGroup122);
} catch {}
try {
computePassEncoder183.setPipeline(pipeline5);
} catch {}
try {
device0.queue.writeBuffer(buffer37, 1452, new Float32Array(2488));
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder77.setPipeline(pipeline5);
} catch {}
document.body.prepend(img2);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let videoFrame66 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'unspecified', transfer: 'smpte240m'} });
try {
computePassEncoder1.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder36.setBindGroup(2, bindGroup196);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer103, 'uint32', 3_864, 18);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let textureView411 = texture330.createView({label: '\ud540\u{1f81e}\u04fe\u4ffd\ufe6d\u0be9\u06f8\u8393'});
try {
computePassEncoder184.setBindGroup(1, bindGroup36);
} catch {}
try {
computePassEncoder6.end();
} catch {}
try {
renderPassEncoder27.setBindGroup(3, bindGroup29, new Uint32Array(1508), 260, 0);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer81, 'uint32', 912, 3_547);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
commandEncoder6.copyBufferToTexture({
  /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 616 */
  offset: 616,
  buffer: buffer2,
}, {
  texture: texture232,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder6.clearBuffer(buffer263, 1064, 3956);
} catch {}
let bindGroup231 = device0.createBindGroup({
  label: '\u0e1b\udfd8\u0cc9\ud539\u090f\u80cf\u0481\u097f\u3fee\u745a',
  layout: bindGroupLayout40,
  entries: [{binding: 470, resource: {buffer: buffer277, offset: 0}}],
});
let texture410 = device0.createTexture({
  label: '\u319c\uaf1f\u34a9',
  size: [27, 4, 20],
  dimension: '2d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView412 = texture200.createView({arrayLayerCount: 1});
let computePassEncoder233 = commandEncoder6.beginComputePass();
let externalTexture55 = device0.importExternalTexture({label: '\u0af1\u{1fa36}', source: videoFrame8, colorSpace: 'display-p3'});
try {
renderPassEncoder4.setViewport(49.068233667263044, 27.49459660748004, 2.8863939665892007, 3.487868298830154, 0.5147443311140615, 0.7615992164166285);
} catch {}
let promise42 = device0.queue.onSubmittedWorkDone();
try {
  await promise41;
} catch {}
let pipelineLayout25 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer299 = device0.createBuffer({
  size: 5412,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let renderBundleEncoder54 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r16float', 'rgba16uint', 'bgra8unorm-srgb', 'rgba16float', 'r16float'],
  sampleCount: 4,
  depthReadOnly: true,
});
let sampler221 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 91.21,
  lodMaxClamp: 96.78,
  maxAnisotropy: 11,
});
let imageData45 = new ImageData(44, 56);
let bindGroup232 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 118, resource: textureView110},
    {binding: 8, resource: textureView270},
    {binding: 348, resource: textureView268},
    {binding: 36, resource: sampler202},
    {binding: 117, resource: {buffer: buffer137, offset: 256, size: 1457}},
    {binding: 29, resource: sampler138},
    {binding: 65, resource: textureView284},
    {binding: 328, resource: textureView352},
    {binding: 125, resource: textureView1},
    {binding: 54, resource: externalTexture26},
    {binding: 408, resource: textureView400},
    {binding: 99, resource: {buffer: buffer74, offset: 0, size: 352}},
    {binding: 195, resource: textureView228},
    {binding: 15, resource: textureView197},
    {binding: 61, resource: textureView63},
    {binding: 162, resource: textureView86},
    {binding: 68, resource: {buffer: buffer6, offset: 3328, size: 800}},
    {binding: 142, resource: textureView56},
    {binding: 697, resource: {buffer: buffer42, offset: 0}},
    {binding: 33, resource: textureView132},
    {binding: 67, resource: textureView289},
    {binding: 330, resource: {buffer: buffer141, offset: 2304, size: 6419}},
    {binding: 216, resource: {buffer: buffer4, offset: 0, size: 1638}},
    {binding: 135, resource: externalTexture11},
    {binding: 62, resource: sampler219},
    {binding: 479, resource: externalTexture49},
    {binding: 55, resource: {buffer: buffer296, offset: 0, size: 112}},
    {binding: 38, resource: sampler20},
    {binding: 47, resource: sampler139},
    {binding: 712, resource: {buffer: buffer13, offset: 7936, size: 7624}},
    {binding: 384, resource: externalTexture29},
    {binding: 5, resource: textureView46},
    {binding: 318, resource: {buffer: buffer81, offset: 256}},
    {binding: 49, resource: {buffer: buffer141, offset: 0, size: 2128}},
    {binding: 209, resource: textureView232},
    {binding: 2, resource: textureView141},
    {binding: 20, resource: externalTexture8},
    {binding: 228, resource: {buffer: buffer225, offset: 1536, size: 3564}},
    {binding: 95, resource: sampler79},
    {binding: 161, resource: textureView128},
    {binding: 141, resource: textureView266},
    {binding: 34, resource: sampler196},
    {binding: 232, resource: {buffer: buffer139, offset: 0, size: 800}},
    {binding: 112, resource: textureView266},
  ],
});
let buffer300 = device0.createBuffer({label: '\u253e\u0ba2', size: 307, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let sampler222 = device0.createSampler({addressModeV: 'repeat', magFilter: 'nearest', lodMinClamp: 73.04, lodMaxClamp: 86.96});
try {
renderPassEncoder10.setBindGroup(2, bindGroup18);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle44]);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer148, 'uint32', 3_592, 442);
} catch {}
try {
renderBundleEncoder54.setBindGroup(0, bindGroup48);
} catch {}
try {
renderBundleEncoder54.setBindGroup(2, bindGroup15, new Uint32Array(830), 469, 0);
} catch {}
try {
renderBundleEncoder54.setIndexBuffer(buffer293, 'uint32', 3_712, 1_352);
} catch {}
try {
renderBundleEncoder54.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder28.insertDebugMarker('\u365d');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer301 = device0.createBuffer({
  size: 1975,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let renderBundle54 = renderBundleEncoder54.finish({});
let sampler223 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 63.44,
  lodMaxClamp: 90.21,
  compare: 'greater-equal',
  maxAnisotropy: 15,
});
try {
computePassEncoder222.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder42.setBindGroup(2, bindGroup138, new Uint32Array(69), 41, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline3);
} catch {}
let gpuCanvasContext16 = offscreenCanvas10.getContext('webgpu');
try {
computePassEncoder112.setPipeline(pipeline7);
} catch {}
let buffer302 = device0.createBuffer({size: 11152, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture411 = device0.createTexture({
  label: '\u07ac\u07e5\uec9c\u{1ff29}\u{1ffdc}\u4189\u{1fb3c}\u{1fe3e}',
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler224 = device0.createSampler({
  label: '\u082d\u3d7d\uf892\u0c4c\u03cb\u6da9',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 65.32,
  lodMaxClamp: 87.17,
  maxAnisotropy: 1,
});
let externalTexture56 = device0.importExternalTexture({source: videoFrame25});
try {
computePassEncoder117.setBindGroup(3, bindGroup26, new Uint32Array(2635), 363, 0);
} catch {}
try {
computePassEncoder83.setPipeline(pipeline2);
} catch {}
try {
if (!arrayBuffer16.detached) { new Uint8Array(arrayBuffer16).fill(0x55); };
} catch {}
document.body.append(canvas7);
try {
adapter0.label = '\u5045\u6987\u6e99\ube3f\u7f8e';
} catch {}
let buffer303 = device0.createBuffer({label: '\ua59b\u360d\u8014', size: 27820, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView413 = texture310.createView({mipLevelCount: 1, baseArrayLayer: 0});
let sampler225 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 90.30,
  compare: 'greater',
});
await gc();
let querySet54 = device0.createQuerySet({type: 'occlusion', count: 2053});
try {
computePassEncoder233.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder42.setBindGroup(2, bindGroup145, new Uint32Array(2685), 938, 0);
} catch {}
try {
renderPassEncoder25.setStencilReference(152);
} catch {}
document.body.prepend(img2);
let texture412 = device0.createTexture({
  size: [26, 20, 8],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture57 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder230.setBindGroup(0, bindGroup100);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline5);
} catch {}
let renderBundleEncoder55 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], stencilReadOnly: true});
try {
renderPassEncoder54.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder55.setBindGroup(0, bindGroup33);
} catch {}
try {
renderBundleEncoder55.setIndexBuffer(buffer33, 'uint32', 444, 1_268);
} catch {}
try {
querySet40.destroy();
} catch {}
let promise43 = device0.queue.onSubmittedWorkDone();
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
canvas0.width = 67;
let videoFrame67 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'gamma28curve'} });
let textureView414 = texture64.createView({
  label: '\u32a1\u0897\u10ef\u03ea\u0228\u1bf7\u345e\u1fac\u{1f99c}\u{1f812}',
  baseArrayLayer: 0,
  arrayLayerCount: 1,
});
let externalTexture58 = device0.importExternalTexture({label: '\u006a\u0204', source: videoFrame65, colorSpace: 'display-p3'});
try {
computePassEncoder115.setBindGroup(0, bindGroup164, new Uint32Array(866), 86, 0);
} catch {}
try {
computePassEncoder227.setPipeline(pipeline5);
} catch {}
let renderBundle55 = renderBundleEncoder55.finish({});
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let buffer304 = device0.createBuffer({
  label: '\u{1f871}\u{1fd85}\u{1fc1d}\u{1f817}',
  size: 5723,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder188.setBindGroup(1, bindGroup66);
} catch {}
try {
renderPassEncoder51.setScissorRect(7, 1, 3, 10);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(6, buffer156);
} catch {}
try {
  await promise42;
} catch {}
await gc();
let bindGroup233 = device0.createBindGroup({layout: bindGroupLayout26, entries: [{binding: 76, resource: textureView175}]});
let sampler226 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 13.64,
  lodMaxClamp: 21.30,
});
try {
computePassEncoder94.setBindGroup(2, bindGroup112);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(1, buffer301);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer263, 3620, new BigUint64Array(57025), 3217, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 625}
*/
{
  source: imageData10,
  origin: { x: 1, y: 1 },
  flipY: true,
}, {
  texture: texture405,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 9},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture413 = device0.createTexture({
  size: [322, 2, 5],
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder138.setPipeline(pipeline5);
} catch {}
try {
  await shaderModule12.getCompilationInfo();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 5, y: 2 },
  flipY: false,
}, {
  texture: texture337,
  mipLevel: 0,
  origin: {x: 27, y: 23, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture414 = device0.createTexture({
  label: '\u{1f77b}\uce08\u6a59\ubd7f\u8db4',
  size: [104, 80, 17],
  format: 'etc2-rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
device0.queue.writeTexture({
  texture: texture137,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(48).fill(62), /* required buffer size: 48 */
{offset: 48}, {width: 141, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView415 = texture127.createView({dimension: '3d'});
let sampler227 = device0.createSampler({
  label: '\u3bb3\u{1fbae}\u0824\u{1f696}\u0ae4\u5e50\u0e6f\u{1f8dd}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 74.69,
  lodMaxClamp: 90.84,
  maxAnisotropy: 18,
});
try {
renderPassEncoder44.setBindGroup(1, bindGroup78, new Uint32Array(4775), 275, 0);
} catch {}
try {
renderPassEncoder51.setVertexBuffer(7, buffer210, 0, 2_312);
} catch {}
let promise44 = device0.queue.onSubmittedWorkDone();
let imageData46 = new ImageData(48, 8);
try {
computePassEncoder86.setBindGroup(0, bindGroup16);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder86); computePassEncoder86.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder43.setBindGroup(0, bindGroup171, new Uint32Array(1269), 211, 0);
} catch {}
try {
renderPassEncoder54.setIndexBuffer(buffer179, 'uint32', 148, 488);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, buffer136);
} catch {}
try {
buffer41.unmap();
} catch {}
let bindGroup234 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 34, resource: sampler206},
    {binding: 697, resource: {buffer: buffer13, offset: 2816, size: 124}},
    {binding: 125, resource: textureView197},
    {binding: 99, resource: {buffer: buffer207, offset: 0}},
    {binding: 20, resource: externalTexture7},
    {binding: 330, resource: {buffer: buffer204, offset: 0, size: 413}},
    {binding: 118, resource: textureView109},
    {binding: 65, resource: textureView109},
    {binding: 328, resource: textureView197},
    {binding: 61, resource: textureView17},
    {binding: 15, resource: textureView100},
    {binding: 49, resource: {buffer: buffer294, offset: 0, size: 1864}},
    {binding: 216, resource: {buffer: buffer284, offset: 6912, size: 20194}},
    {binding: 29, resource: sampler0},
    {binding: 712, resource: {buffer: buffer48, offset: 0, size: 540}},
    {binding: 384, resource: externalTexture57},
    {binding: 228, resource: {buffer: buffer169, offset: 0, size: 3152}},
    {binding: 2, resource: textureView51},
    {binding: 47, resource: sampler19},
    {binding: 36, resource: sampler4},
    {binding: 55, resource: {buffer: buffer177, offset: 768, size: 584}},
    {binding: 62, resource: sampler97},
    {binding: 117, resource: {buffer: buffer91, offset: 5376}},
    {binding: 232, resource: {buffer: buffer157, offset: 512, size: 908}},
    {binding: 33, resource: textureView132},
    {binding: 348, resource: textureView15},
    {binding: 135, resource: externalTexture50},
    {binding: 209, resource: textureView174},
    {binding: 95, resource: sampler196},
    {binding: 142, resource: textureView13},
    {binding: 5, resource: textureView153},
    {binding: 479, resource: externalTexture47},
    {binding: 141, resource: textureView75},
    {binding: 67, resource: textureView353},
    {binding: 318, resource: {buffer: buffer281, offset: 0, size: 36}},
    {binding: 68, resource: {buffer: buffer8, offset: 5632, size: 6992}},
    {binding: 161, resource: textureView289},
    {binding: 162, resource: textureView118},
    {binding: 38, resource: sampler114},
    {binding: 54, resource: externalTexture8},
    {binding: 112, resource: textureView266},
    {binding: 195, resource: textureView228},
    {binding: 408, resource: textureView191},
    {binding: 8, resource: textureView61},
  ],
});
let sampler228 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 79.13,
  lodMaxClamp: 95.65,
  compare: 'less-equal',
});
try {
computePassEncoder190.setBindGroup(2, bindGroup130);
} catch {}
try {
renderPassEncoder30.setBindGroup(2, bindGroup81);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer83, 'uint16', 734, 1_209);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let imageBitmap14 = await createImageBitmap(imageData34);
let textureView416 = texture90.createView({label: '\u8568\u7489', baseArrayLayer: 11, arrayLayerCount: 7});
try {
computePassEncoder155.setBindGroup(0, bindGroup159, new Uint32Array(815), 183, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup123);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline3);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.append(img2);
try {
computePassEncoder7.setBindGroup(3, bindGroup15);
} catch {}
try {
computePassEncoder110.setBindGroup(0, bindGroup180, new Uint32Array(4314), 595, 0);
} catch {}
try {
renderPassEncoder28.setBindGroup(2, bindGroup14, new Uint32Array(1727), 83, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let bindGroup235 = device0.createBindGroup({
  layout: bindGroupLayout35,
  entries: [{binding: 681, resource: {buffer: buffer20, offset: 512, size: 208}}],
});
let buffer305 = device0.createBuffer({
  label: '\u1c05\u9e5c\u064f\u216f',
  size: 220,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let textureView417 = texture408.createView({mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 1});
try {
renderPassEncoder3.setBindGroup(1, bindGroup176, new Uint32Array(614), 60, 1);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(6, undefined, 0, 125_105_745);
} catch {}
let imageData47 = new ImageData(4, 20);
let buffer306 = device0.createBuffer({
  label: '\u98f1\uca00\uabd5',
  size: 6353,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
try {
computePassEncoder166.setBindGroup(2, bindGroup211, new Uint32Array(516), 88, 0);
} catch {}
try {
renderPassEncoder53.setBindGroup(3, bindGroup100, new Uint32Array(2526), 200, 0);
} catch {}
let bindGroup236 = device0.createBindGroup({
  layout: bindGroupLayout32,
  entries: [
    {binding: 17, resource: {buffer: buffer2, offset: 5632}},
    {binding: 338, resource: {buffer: buffer166, offset: 6400}},
  ],
});
let texture415 = gpuCanvasContext10.getCurrentTexture();
let textureView418 = texture8.createView({label: '\u84d3\u8bde\ufe78\u2307\u09f9\ua273\uede2', baseArrayLayer: 0});
try {
computePassEncoder125.setBindGroup(2, bindGroup32);
} catch {}
try {
renderPassEncoder51.executeBundles([renderBundle42, renderBundle48, renderBundle29, renderBundle48]);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
let imageData48 = new ImageData(56, 64);
let texture416 = device0.createTexture({
  label: '\u1ea0\u8072\ua8e3\u34c5\u012e\u0d2a',
  size: {width: 645, height: 4, depthOrArrayLayers: 62},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView419 = texture89.createView({label: '\u076f\uc6a9\ubae9\ue6f0\u145d\u{1fd2e}\ueb8c\u08ae\u{1fb34}\u0927\u6fb7', mipLevelCount: 1});
let sampler229 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 13.31,
  lodMaxClamp: 62.05,
  compare: 'never',
  maxAnisotropy: 14,
});
try {
computePassEncoder29.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup166, []);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer41, 0);
} catch {}
let promise45 = device0.queue.onSubmittedWorkDone();
let bindGroup237 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 185, resource: textureView3},
    {binding: 6, resource: textureView51},
    {binding: 195, resource: textureView6},
    {binding: 196, resource: textureView135},
    {binding: 349, resource: sampler66},
    {binding: 79, resource: {buffer: buffer258, offset: 7168, size: 2552}},
    {binding: 190, resource: textureView146},
    {binding: 351, resource: {buffer: buffer98, offset: 1280, size: 1442}},
    {binding: 0, resource: {buffer: buffer22, offset: 512, size: 3160}},
    {binding: 163, resource: sampler92},
    {binding: 143, resource: {buffer: buffer1, offset: 2304, size: 2043}},
    {binding: 47, resource: textureView137},
    {binding: 88, resource: textureView264},
    {binding: 110, resource: textureView370},
    {binding: 160, resource: textureView112},
    {binding: 68, resource: {buffer: buffer206, offset: 512, size: 453}},
    {binding: 306, resource: textureView90},
    {binding: 12, resource: {buffer: buffer296, offset: 0, size: 2024}},
    {binding: 252, resource: {buffer: buffer184, offset: 0, size: 528}},
    {binding: 14, resource: {buffer: buffer279, offset: 512}},
    {binding: 177, resource: textureView3},
    {binding: 44, resource: sampler40},
    {binding: 287, resource: textureView351},
    {binding: 8, resource: textureView201},
    {binding: 523, resource: textureView338},
    {binding: 70, resource: textureView76},
    {binding: 255, resource: {buffer: buffer154, offset: 4864, size: 16824}},
    {binding: 389, resource: textureView181},
  ],
});
let bindGroup238 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 389, resource: textureView55}, {binding: 148, resource: textureView290}],
});
let textureView420 = texture45.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 11});
let sampler230 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 77.46,
  lodMaxClamp: 89.67,
});
try {
computePassEncoder93.setBindGroup(3, bindGroup144);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder86); computePassEncoder86.dispatchWorkgroups(1, 1, 2); };
} catch {}
try {
computePassEncoder86.end();
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline1);
} catch {}
document.body.append(canvas1);
let renderPassEncoder55 = commandEncoder104.beginRenderPass({
  colorAttachments: [{
  view: textureView144,
  clearValue: { r: 458.7, g: 159.0, b: 371.6, a: 109.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet49,
});
try {
computePassEncoder44.setBindGroup(2, bindGroup110);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer91, 'uint16', 258, 1_835);
} catch {}
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let bindGroup239 = device0.createBindGroup({label: '\uffe5\ue2f1\u0e01', layout: bindGroupLayout1, entries: []});
let buffer307 = device0.createBuffer({
  label: '\u0ad5\u7f47\u0e68\u0104\u{1f7be}\u{1fe98}\u473c\u9451\ucee1',
  size: 22984,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture417 = device0.createTexture({
  size: [13, 2, 1],
  sampleCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView421 = texture62.createView({
  label: '\u{1f609}\u01e4\u{1fa93}\uabcc\ubd46\u{1fd9f}\u005c\u{1fb67}\u0c29\u6fa6\uda54',
  dimension: 'cube-array',
  baseArrayLayer: 1,
  arrayLayerCount: 6,
});
try {
device0.queue.writeBuffer(buffer49, 3428, new DataView(new ArrayBuffer(2669)), 532, 976);
} catch {}
let bindGroup240 = device0.createBindGroup({
  layout: bindGroupLayout36,
  entries: [
    {binding: 105, resource: {buffer: buffer10, offset: 256, size: 1481}},
    {binding: 170, resource: textureView37},
    {binding: 50, resource: textureView420},
    {binding: 35, resource: textureView304},
    {binding: 140, resource: {buffer: buffer29, offset: 7936}},
  ],
});
let sampler231 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.65,
  maxAnisotropy: 11,
});
try {
computePassEncoder191.setBindGroup(2, bindGroup117);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(0, buffer37, 744, 3_586);
} catch {}
try {
renderPassEncoder28.insertDebugMarker('\u{1fe69}');
} catch {}
await gc();
try {
buffer184.label = '\u88c2\u8f25\u{1ff12}\u8d45\u5ac5\u04e4\u02bf\u0fa3\uc3d7\u{1f800}\u27e3';
} catch {}
try {
computePassEncoder138.setBindGroup(1, bindGroup230, new Uint32Array(1816), 210, 0);
} catch {}
try {
renderPassEncoder36.executeBundles([renderBundle29, renderBundle44, renderBundle27, renderBundle44]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer298, 'uint16', 6_840, 447);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let textureView422 = texture89.createView({mipLevelCount: 1});
let sampler232 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 71.65,
  lodMaxClamp: 92.84,
  maxAnisotropy: 5,
});
let externalTexture59 = device0.importExternalTexture({source: videoFrame48});
try {
renderPassEncoder30.setBindGroup(0, bindGroup189, new Uint32Array(3676), 1_029, 1);
} catch {}
try {
renderPassEncoder27.setViewport(22.454793258618043, 2.187617551481444, 10.667778110291035, 0.4742866958468423, 0.23578371988401536, 0.5514935174821438);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer255, 0, 352);
} catch {}
try {
computePassEncoder123.insertDebugMarker('\u6f7d');
} catch {}
let bindGroup241 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 54, resource: externalTexture38},
    {binding: 195, resource: textureView145},
    {binding: 479, resource: externalTexture53},
    {binding: 318, resource: {buffer: buffer200, offset: 5632, size: 8596}},
    {binding: 712, resource: {buffer: buffer48, offset: 0, size: 476}},
    {binding: 118, resource: textureView3},
    {binding: 384, resource: externalTexture3},
    {binding: 15, resource: textureView1},
    {binding: 216, resource: {buffer: buffer29, offset: 2304}},
    {binding: 112, resource: textureView270},
    {binding: 408, resource: textureView79},
    {binding: 697, resource: {buffer: buffer29, offset: 512}},
    {binding: 330, resource: {buffer: buffer11, offset: 2560, size: 357}},
    {binding: 348, resource: textureView268},
    {binding: 209, resource: textureView197},
    {binding: 65, resource: textureView110},
    {binding: 95, resource: sampler109},
    {binding: 141, resource: textureView266},
    {binding: 38, resource: sampler164},
    {binding: 228, resource: {buffer: buffer61, offset: 5120, size: 3452}},
    {binding: 61, resource: textureView47},
    {binding: 2, resource: textureView396},
    {binding: 162, resource: textureView139},
    {binding: 161, resource: textureView149},
    {binding: 67, resource: textureView128},
    {binding: 36, resource: sampler145},
    {binding: 117, resource: {buffer: buffer25, offset: 0, size: 756}},
    {binding: 49, resource: {buffer: buffer158, offset: 256, size: 1696}},
    {binding: 68, resource: {buffer: buffer281, offset: 256, size: 348}},
    {binding: 29, resource: sampler76},
    {binding: 55, resource: {buffer: buffer276, offset: 0, size: 36}},
    {binding: 20, resource: externalTexture53},
    {binding: 8, resource: textureView266},
    {binding: 125, resource: textureView109},
    {binding: 135, resource: externalTexture20},
    {binding: 47, resource: sampler153},
    {binding: 142, resource: textureView196},
    {binding: 232, resource: {buffer: buffer37, offset: 768}},
    {binding: 5, resource: textureView344},
    {binding: 62, resource: sampler177},
    {binding: 99, resource: {buffer: buffer304, offset: 1024, size: 737}},
    {binding: 33, resource: textureView143},
    {binding: 34, resource: sampler153},
    {binding: 328, resource: textureView293},
  ],
});
let pipelineLayout26 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView423 = texture3.createView({label: '\ud8b6\u304b\udb5a\u3cb0\u8c73', aspect: 'depth-only', baseArrayLayer: 33, arrayLayerCount: 18});
let sampler233 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 27.41,
  lodMaxClamp: 93.28,
});
try {
renderPassEncoder51.setBindGroup(0, bindGroup120, new Uint32Array(1001), 6, 0);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer170, 'uint32', 2_108, 2_821);
} catch {}
let texture418 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 32},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler234 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'linear',
  lodMinClamp: 65.70,
  lodMaxClamp: 80.05,
});
try {
renderPassEncoder11.setBindGroup(0, bindGroup194);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle34, renderBundle2]);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
globalThis.someLabel = querySet41.label;
} catch {}
let buffer308 = device0.createBuffer({
  size: 7556,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder194.setBindGroup(3, bindGroup115);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup0, new Uint32Array(554), 207, 0);
} catch {}
try {
renderPassEncoder46.executeBundles([renderBundle27, renderBundle42, renderBundle42, renderBundle42, renderBundle27, renderBundle55, renderBundle48, renderBundle42, renderBundle29]);
} catch {}
try {
globalThis.someLabel = externalTexture57.label;
} catch {}
let bindGroup242 = device0.createBindGroup({layout: bindGroupLayout18, entries: [{binding: 43, resource: textureView178}]});
let texture419 = device0.createTexture({
  size: [645, 4, 1],
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder167.setBindGroup(0, bindGroup137);
} catch {}
try {
computePassEncoder130.setBindGroup(3, bindGroup135, new Uint32Array(1283), 60, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer77, 'uint32', 2_252, 1_020);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer158, 412, 38);
} catch {}
let videoFrame68 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt709', transfer: 'smpteSt4281'} });
let bindGroup243 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [{binding: 197, resource: {buffer: buffer62, offset: 10496}}, {binding: 46, resource: textureView169}],
});
try {
computePassEncoder167.setBindGroup(3, bindGroup125);
} catch {}
try {
renderPassEncoder35.setBindGroup(1, bindGroup211, new Uint32Array(409), 144, 0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle34]);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer49, 508, new Float32Array(1842), 67, 628);
} catch {}
await gc();
let bindGroup244 = device0.createBindGroup({
  layout: bindGroupLayout42,
  entries: [
    {binding: 43, resource: sampler117},
    {binding: 306, resource: sampler140},
    {binding: 17, resource: textureView118},
    {binding: 59, resource: textureView381},
    {binding: 31, resource: textureView123},
  ],
});
try {
renderPassEncoder12.setBindGroup(0, bindGroup69, new Uint32Array(4007), 690, 0);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(7, buffer261);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture215,
  mipLevel: 0,
  origin: {x: 22, y: 2, z: 2},
  aspect: 'all',
}, new Uint8Array(229).fill(230), /* required buffer size: 229 */
{offset: 229}, {width: 281, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroupLayout50 = device0.createBindGroupLayout({
  label: '\u8dc5\u66cf\u0c5c\u5cd5\u920c\u{1fbe8}\u49d3\ub2ca\u758b\u75b6',
  entries: [
    {
      binding: 182,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' },
    },
  ],
});
let buffer309 = device0.createBuffer({label: '\u{1fa63}\u2ce2\u6d1d\u{1fc1c}', size: 14145, usage: GPUBufferUsage.UNIFORM});
let texture420 = device0.createTexture({
  size: [26, 20, 68],
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder45.setBindGroup(2, bindGroup145);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer242, 'uint16', 578, 562);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
document.body.append(img0);
let bindGroup245 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [
    {binding: 289, resource: textureView329},
    {binding: 196, resource: sampler38},
    {binding: 74, resource: textureView333},
    {binding: 380, resource: textureView51},
    {binding: 230, resource: textureView315},
    {binding: 206, resource: textureView106},
    {binding: 220, resource: textureView197},
    {binding: 119, resource: textureView256},
  ],
});
let buffer310 = device0.createBuffer({
  size: 4938,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView424 = texture420.createView({dimension: '2d', baseArrayLayer: 2});
try {
renderPassEncoder42.setBindGroup(1, bindGroup233);
} catch {}
try {
renderPassEncoder17.setStencilReference(251);
} catch {}
try {
renderPassEncoder49.setIndexBuffer(buffer78, 'uint16', 174, 2_551);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(6, buffer298);
} catch {}
await gc();
try {
externalTexture40.label = '\u0abc\u04ff\u35a5\u7d2e\uda24\u{1f9dd}';
} catch {}
try {
computePassEncoder179.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder53.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(6, buffer72, 4_472, 1_814);
} catch {}
let canvas9 = document.createElement('canvas');
let textureView425 = texture420.createView({label: '\u2983\u6fde', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 11});
let textureView426 = texture134.createView({dimension: 'cube-array', baseArrayLayer: 11, arrayLayerCount: 6});
let sampler235 = device0.createSampler({
  label: '\ud8de\u{1fca2}\u{1fba5}\uc152\u0323',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 46.54,
  lodMaxClamp: 57.90,
});
try {
computePassEncoder104.setBindGroup(2, bindGroup164, new Uint32Array(3752), 533, 0);
} catch {}
try {
renderPassEncoder28.setBindGroup(1, bindGroup106, new Uint32Array(3266), 230, 0);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(6, buffer225, 4_404);
} catch {}
try {
if (!arrayBuffer33.detached) { new Uint8Array(arrayBuffer33).fill(0x55); };
} catch {}
let bindGroup246 = device0.createBindGroup({
  layout: bindGroupLayout22,
  entries: [
    {binding: 92, resource: textureView281},
    {binding: 5, resource: textureView333},
    {binding: 594, resource: textureView3},
    {binding: 46, resource: textureView396},
    {binding: 440, resource: sampler102},
  ],
});
let buffer311 = device0.createBuffer({size: 4067, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let textureView427 = texture134.createView({
  label: '\u{1fe5c}\uc6db\u{1f77f}\u{1f9d0}\u11e3\u503f\u1f2a\ubf66',
  dimension: 'cube-array',
  baseArrayLayer: 1,
  arrayLayerCount: 24,
});
let sampler236 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 16.57,
});
try {
renderPassEncoder30.setBindGroup(1, bindGroup114, new Uint32Array(987), 14, 0);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle40, renderBundle17]);
} catch {}
let arrayBuffer40 = buffer217.getMappedRange(128, 20);
let sampler237 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 14.81,
  lodMaxClamp: 43.30,
  compare: 'equal',
});
try {
computePassEncoder123.setBindGroup(0, bindGroup164, new Uint32Array(1737), 12, 0);
} catch {}
try {
renderPassEncoder7.setBlendConstant({ r: -594.4, g: -188.7, b: -640.8, a: -194.0, });
} catch {}
let bindGroup247 = device0.createBindGroup({
  label: '\uaa45\u{1feeb}\u3d56\u9052\ubf0b\u20f4\u7f56',
  layout: bindGroupLayout9,
  entries: [
    {binding: 495, resource: {buffer: buffer8, offset: 3328, size: 1245}},
    {binding: 108, resource: {buffer: buffer242, offset: 256, size: 24}},
    {binding: 268, resource: textureView290},
    {binding: 0, resource: textureView4},
    {binding: 58, resource: textureView61},
    {binding: 8, resource: {buffer: buffer48, offset: 0, size: 244}},
    {binding: 66, resource: textureView103},
    {binding: 319, resource: externalTexture5},
    {binding: 156, resource: textureView194},
    {binding: 72, resource: {buffer: buffer250, offset: 1792, size: 2852}},
    {binding: 134, resource: textureView85},
    {binding: 207, resource: textureView55},
    {binding: 189, resource: textureView82},
    {binding: 25, resource: {buffer: buffer55, offset: 0, size: 128}},
  ],
});
let texture421 = device0.createTexture({
  size: {width: 13},
  dimension: '1d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let texture422 = gpuCanvasContext7.getCurrentTexture();
let sampler238 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 24.47,
  lodMaxClamp: 54.12,
  maxAnisotropy: 17,
});
try {
computePassEncoder100.setBindGroup(0, bindGroup120, new Uint32Array(1025), 291, 0);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer75, 'uint32', 4_192, 4_977);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(1, buffer166);
} catch {}
let gpuCanvasContext17 = canvas9.getContext('webgpu');
let texture423 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 64},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder216.setBindGroup(2, bindGroup176, [0]);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup147);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer251, 'uint32', 856, 688);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(1, buffer261);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 27}
*/
{
  source: imageData22,
  origin: { x: 5, y: 1 },
  flipY: false,
}, {
  texture: texture205,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture424 = device0.createTexture({size: [55, 8, 1], format: 'rg32float', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
try {
computePassEncoder109.setBindGroup(1, bindGroup49);
} catch {}
try {
renderPassEncoder46.setBindGroup(1, bindGroup174, []);
} catch {}
try {
renderPassEncoder48.setBindGroup(0, bindGroup74, new Uint32Array(6), 0, 0);
} catch {}
try {
renderPassEncoder53.beginOcclusionQuery(312);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer82, 'uint16', 3_868, 1_778);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline1);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img0);
try {
computePassEncoder72.setBindGroup(3, bindGroup200);
} catch {}
document.body.append(img2);
let bindGroup248 = device0.createBindGroup({
  label: '\u{1fc0a}\u{1fb4b}\ue8b5\u{1fe53}\u82c7\u0789',
  layout: bindGroupLayout34,
  entries: [{binding: 278, resource: textureView22}],
});
let texture425 = device0.createTexture({
  size: [1290, 8, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder17.setBindGroup(1, bindGroup143, new Uint32Array(781), 485, 0);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(2, buffer239, 0, 27);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 376, new Int16Array(4526), 476, 116);
} catch {}
let texture426 = device0.createTexture({
  size: {width: 52, height: 40, depthOrArrayLayers: 6},
  dimension: '2d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView428 = texture107.createView({dimension: '2d'});
try {
renderPassEncoder42.setIndexBuffer(buffer288, 'uint16', 880, 1_353);
} catch {}
try {
computePassEncoder178.setBindGroup(0, bindGroup227);
} catch {}
try {
renderPassEncoder34.setBindGroup(3, bindGroup35);
} catch {}
try {
renderPassEncoder53.endOcclusionQuery();
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer252, 'uint16', 96, 3_444);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
gpuCanvasContext4.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'display-p3'});
} catch {}
let buffer312 = device0.createBuffer({size: 5782, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView429 = texture245.createView({
  label: '\u0a4d\ub135\u0be7\u019f\ue359\u0c1f\udff6\u0eff\u0ece\u{1fdf2}\u2c04',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 3,
  arrayLayerCount: 4,
});
try {
computePassEncoder58.setBindGroup(2, bindGroup135, new Uint32Array(170), 25, 0);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle3, renderBundle18]);
} catch {}
try {
renderPassEncoder55.setIndexBuffer(buffer16, 'uint32', 4_664, 2_553);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1290, height: 8, depthOrArrayLayers: 10}
*/
{
  source: imageData32,
  origin: { x: 33, y: 2 },
  flipY: true,
}, {
  texture: texture215,
  mipLevel: 0,
  origin: {x: 249, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 9, height: 2, depthOrArrayLayers: 0});
} catch {}
let textureView430 = texture362.createView({label: '\u8330\u{1f722}\u7add\u1a6c\u{1fa46}\uff07\ufaff\ufa1c\u8e0d\u7eb8'});
try {
renderPassEncoder28.setBindGroup(0, bindGroup105, []);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(4, buffer239, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext16.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let bindGroup249 = device0.createBindGroup({
  layout: bindGroupLayout42,
  entries: [
    {binding: 17, resource: textureView428},
    {binding: 59, resource: textureView386},
    {binding: 43, resource: sampler30},
    {binding: 306, resource: sampler192},
    {binding: 31, resource: textureView395},
  ],
});
let texture427 = device0.createTexture({
  size: [322, 2, 52],
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler239 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 63.92,
  lodMaxClamp: 75.77,
});
try {
computePassEncoder135.setBindGroup(2, bindGroup249, new Uint32Array(227), 88, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let promise46 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData27,
  origin: { x: 7, y: 0 },
  flipY: false,
}, {
  texture: texture316,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer313 = device0.createBuffer({size: 6062, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let texture428 = device0.createTexture({
  size: [104, 80, 1],
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture374,
  mipLevel: 0,
  origin: {x: 94, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(61).fill(23), /* required buffer size: 61 */
{offset: 61}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer33.detached) { new Uint8Array(arrayBuffer33).fill(0x55); };
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup171, new Uint32Array(1900), 429, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer310, 'uint32', 1_120, 965);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer279, 7500, new Float32Array(606));
} catch {}
try {
  await promise39;
} catch {}
let renderBundleEncoder56 = device0.createRenderBundleEncoder({colorFormats: ['r8uint'], depthStencilFormat: 'stencil8'});
try {
computePassEncoder40.setBindGroup(1, bindGroup18);
} catch {}
try {
computePassEncoder77.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder56.setBindGroup(3, bindGroup96);
} catch {}
try {
renderBundleEncoder56.setBindGroup(3, bindGroup100, new Uint32Array(496), 45, 0);
} catch {}
try {
renderBundleEncoder56.setVertexBuffer(7, buffer308);
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
let videoFrame69 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpte432', transfer: 'hlg'} });
let querySet55 = device0.createQuerySet({type: 'occlusion', count: 174});
let texture429 = device0.createTexture({
  size: [52, 40, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView431 = texture375.createView({aspect: 'stencil-only', mipLevelCount: 1});
try {
computePassEncoder114.setBindGroup(2, bindGroup164, new Uint32Array(296), 16, 0);
} catch {}
try {
renderPassEncoder34.executeBundles([renderBundle34, renderBundle0, renderBundle34]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer295, 'uint16', 1_514, 2_971);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(7, undefined, 0, 766_033_397);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame70 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'unspecified'} });
try {
computePassEncoder148.setBindGroup(1, bindGroup49);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder49.setVertexBuffer(7, buffer281, 0, 22);
} catch {}
try {
renderBundleEncoder56.setBindGroup(3, bindGroup50, new Uint32Array(2390), 987, 0);
} catch {}
try {
renderBundleEncoder56.setIndexBuffer(buffer282, 'uint16', 32, 142);
} catch {}
try {
gpuCanvasContext13.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let renderBundle56 = renderBundleEncoder56.finish({label: '\u{1ff39}\u0355\u0e33\u0144\u{1f8d6}\ud05d\u0fd3'});
try {
computePassEncoder98.setBindGroup(2, bindGroup173);
} catch {}
try {
renderPassEncoder53.setPipeline(pipeline3);
} catch {}
try {
buffer305.unmap();
} catch {}
let pipelineLayout27 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer314 = device0.createBuffer({
  size: 10019,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture430 = device0.createTexture({
  label: '\u0ab3\u{1fbb0}\u{1f8c4}\ub8b4',
  size: {width: 26, height: 20, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder157.setBindGroup(2, bindGroup97);
} catch {}
let bindGroup250 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 62, resource: sampler76},
    {binding: 408, resource: textureView28},
    {binding: 34, resource: sampler92},
    {binding: 712, resource: {buffer: buffer177, offset: 256, size: 1836}},
    {binding: 384, resource: externalTexture21},
    {binding: 55, resource: {buffer: buffer3, offset: 0, size: 120}},
    {binding: 118, resource: textureView284},
    {binding: 209, resource: textureView392},
    {binding: 15, resource: textureView108},
    {binding: 228, resource: {buffer: buffer306, offset: 256, size: 3296}},
    {binding: 67, resource: textureView290},
    {binding: 33, resource: textureView287},
    {binding: 125, resource: textureView284},
    {binding: 479, resource: externalTexture8},
    {binding: 330, resource: {buffer: buffer20, offset: 768, size: 2616}},
    {binding: 5, resource: textureView176},
    {binding: 65, resource: textureView3},
    {binding: 38, resource: sampler197},
    {binding: 216, resource: {buffer: buffer91, offset: 0, size: 1636}},
    {binding: 8, resource: textureView61},
    {binding: 232, resource: {buffer: buffer185, offset: 1280}},
    {binding: 142, resource: textureView385},
    {binding: 318, resource: {buffer: buffer310, offset: 768, size: 964}},
    {binding: 29, resource: sampler94},
    {binding: 161, resource: textureView298},
    {binding: 328, resource: textureView228},
    {binding: 135, resource: externalTexture14},
    {binding: 112, resource: textureView266},
    {binding: 162, resource: textureView118},
    {binding: 348, resource: textureView194},
    {binding: 2, resource: textureView315},
    {binding: 36, resource: sampler35},
    {binding: 141, resource: textureView266},
    {binding: 99, resource: {buffer: buffer139, offset: 0, size: 1355}},
    {binding: 54, resource: externalTexture8},
    {binding: 117, resource: {buffer: buffer167, offset: 0, size: 684}},
    {binding: 68, resource: {buffer: buffer37, offset: 1280}},
    {binding: 195, resource: textureView268},
    {binding: 95, resource: sampler224},
    {binding: 697, resource: {buffer: buffer200, offset: 2816, size: 3576}},
    {binding: 61, resource: textureView21},
    {binding: 20, resource: externalTexture13},
    {binding: 47, resource: sampler38},
    {binding: 49, resource: {buffer: buffer152, offset: 8448, size: 5856}},
  ],
});
let querySet56 = device0.createQuerySet({type: 'occlusion', count: 1571});
let arrayBuffer41 = buffer162.getMappedRange(72, 24);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 5}
*/
{
  source: imageBitmap10,
  origin: { x: 22, y: 56 },
  flipY: false,
}, {
  texture: texture413,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture431 = device0.createTexture({
  size: [645, 4, 62],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder34.setBindGroup(0, bindGroup247);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder53.setVertexBuffer(7, buffer251);
} catch {}
try {
computePassEncoder43.setBindGroup(0, bindGroup233, []);
} catch {}
try {
computePassEncoder61.setBindGroup(2, bindGroup228, new Uint32Array(3535), 1_001, 0);
} catch {}
try {
computePassEncoder71.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder45.setBindGroup(3, bindGroup244, new Uint32Array(688), 10, 0);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(7, buffer180, 24, 841);
} catch {}
let bindGroup251 = device0.createBindGroup({layout: bindGroupLayout35, entries: [{binding: 681, resource: {buffer: buffer42, offset: 512}}]});
let externalTexture60 = device0.importExternalTexture({source: videoFrame36});
try {
renderPassEncoder21.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer81, 'uint16', 946, 148);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(3, buffer295, 0, 1_205);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: videoFrame45,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture316,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer315 = device0.createBuffer({size: 210, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
try {
renderPassEncoder11.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 1, y: 3 },
  flipY: false,
}, {
  texture: texture238,
  mipLevel: 0,
  origin: {x: 145, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 24, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView432 = texture193.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let sampler240 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 10.60,
  lodMaxClamp: 13.37,
});
try {
renderPassEncoder34.setBindGroup(2, bindGroup60);
} catch {}
try {
renderPassEncoder31.setBindGroup(3, bindGroup117, new Uint32Array(488), 114, 0);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle18, renderBundle1]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer48, 'uint16', 36);
} catch {}
await gc();
let texture432 = device0.createTexture({
  size: [645, 4, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView433 = texture35.createView({dimension: '1d'});
let sampler241 = device0.createSampler({
  label: '\ua49f\uac08\u0298\u3313',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 99.11,
});
let externalTexture61 = device0.importExternalTexture({source: videoFrame48, colorSpace: 'srgb'});
try {
renderPassEncoder29.executeBundles([renderBundle27, renderBundle48]);
} catch {}
try {
renderPassEncoder54.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(6, buffer24, 2_552);
} catch {}
try {
device0.queue.writeBuffer(buffer49, 1036, new DataView(new ArrayBuffer(15452)), 2929, 1276);
} catch {}
let promise47 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1290, height: 8, depthOrArrayLayers: 10}
*/
{
  source: videoFrame21,
  origin: { x: 57, y: 21 },
  flipY: true,
}, {
  texture: texture215,
  mipLevel: 0,
  origin: {x: 128, y: 1, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 94, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise40;
} catch {}
let sampler242 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 64.88,
  lodMaxClamp: 79.37,
  maxAnisotropy: 16,
});
try {
renderPassEncoder12.setBindGroup(0, bindGroup187);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup203, new Uint32Array(3773), 161, 0);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 1}
*/
{
  source: videoFrame55,
  origin: { x: 0, y: 6 },
  flipY: false,
}, {
  texture: texture369,
  mipLevel: 1,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler243 = device0.createSampler({magFilter: 'nearest', minFilter: 'nearest', lodMinClamp: 70.02, lodMaxClamp: 77.66});
try {
computePassEncoder55.setBindGroup(2, bindGroup170, new Uint32Array(2038), 293, 0);
} catch {}
try {
  await buffer305.mapAsync(GPUMapMode.WRITE, 0, 80);
} catch {}
try {
device0.queue.writeBuffer(buffer92, 3000, new Int16Array(25214), 2613, 980);
} catch {}
let offscreenCanvas11 = new OffscreenCanvas(244, 177);
try {
renderPassEncoder12.setIndexBuffer(buffer301, 'uint16', 828, 117);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
renderPassEncoder4.pushDebugGroup('\u6179');
} catch {}
try {
renderPassEncoder4.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer50, 5208, new DataView(new ArrayBuffer(21978)), 4305, 260);
} catch {}
let textureView434 = texture81.createView({});
try {
renderPassEncoder22.setBindGroup(1, bindGroup6);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1290, height: 8, depthOrArrayLayers: 10}
*/
{
  source: imageBitmap13,
  origin: { x: 4, y: 3 },
  flipY: true,
}, {
  texture: texture215,
  mipLevel: 0,
  origin: {x: 189, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 8, depthOrArrayLayers: 0});
} catch {}
let texture433 = device0.createTexture({
  size: [13, 10, 16],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView435 = texture320.createView({mipLevelCount: 1});
try {
renderPassEncoder14.setBindGroup(3, bindGroup153, new Uint32Array(195), 14, 0);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer165);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await promise47;
} catch {}
let buffer316 = device0.createBuffer({size: 9850, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let sampler244 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'clamp-to-edge', mipmapFilter: 'linear', lodMinClamp: 27.69});
try {
computePassEncoder91.setBindGroup(1, bindGroup224, new Uint32Array(1017), 46, 0);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle27]);
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); };
} catch {}
try {
  await promise46;
} catch {}
let buffer317 = device0.createBuffer({
  label: '\u0487\udca9\u09cd\u0531\u083c\u0a8c\u41bc',
  size: 18839,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture434 = device0.createTexture({
  size: [110, 16, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder136.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder43.setBindGroup(1, bindGroup28);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
let arrayBuffer42 = buffer59.getMappedRange(160, 1312);
let buffer318 = device0.createBuffer({size: 28114, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder115.setBindGroup(1, bindGroup88, new Uint32Array(410), 11, 0);
} catch {}
try {
renderPassEncoder37.setBindGroup(3, bindGroup106, new Uint32Array(1399), 94, 0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(6, buffer24, 2_920, 6_458);
} catch {}
let externalTexture62 = device0.importExternalTexture({source: videoFrame35});
try {
computePassEncoder72.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder45.setScissorRect(26, 7, 3, 2);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer311, 232, 731);
} catch {}
let arrayBuffer43 = buffer305.getMappedRange(0, 24);
try {
  await promise45;
} catch {}
let textureView436 = texture312.createView({});
try {
computePassEncoder156.setBindGroup(2, bindGroup64, []);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData21,
  origin: { x: 2, y: 11 },
  flipY: false,
}, {
  texture: texture369,
  mipLevel: 2,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext18 = offscreenCanvas11.getContext('webgpu');
let buffer319 = device0.createBuffer({size: 8695, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture435 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 32},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView437 = texture397.createView({dimension: '2d', baseArrayLayer: 6});
try {
computePassEncoder148.setBindGroup(2, bindGroup227, new Uint32Array(611), 39, 0);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline1);
} catch {}
try {
  await promise43;
} catch {}
let imageData49 = new ImageData(24, 28);
try {
renderPassEncoder18.executeBundles([renderBundle0, renderBundle47, renderBundle26]);
} catch {}
try {
adapter0.label = '\u{1fc1a}\uffe2\u0bdd\uf110\u{1fb71}\ue05f';
} catch {}
let bindGroup252 = device0.createBindGroup({
  label: '\u{1fc7d}\u0afe\u0fa2\u6b37\ude90\ud7e8\u05e5\u0b70\u21d0\u3a1b',
  layout: bindGroupLayout23,
  entries: [
    {binding: 208, resource: textureView392},
    {binding: 159, resource: textureView146},
    {binding: 31, resource: textureView208},
  ],
});
let buffer320 = device0.createBuffer({
  size: 3270,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler245 = device0.createSampler({
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 78.82,
  lodMaxClamp: 83.91,
});
try {
computePassEncoder98.setBindGroup(2, bindGroup10, new Uint32Array(1210), 43, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup143, new Uint32Array(321), 47, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer36, 1504, new Float32Array(7755), 368, 408);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 2, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap14,
  origin: { x: 1, y: 1 },
  flipY: false,
}, {
  texture: texture407,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler246 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.54,
  lodMaxClamp: 99.92,
  compare: 'greater',
  maxAnisotropy: 16,
});
try {
renderPassEncoder17.setIndexBuffer(buffer169, 'uint16', 446, 1_733);
} catch {}
try {
if (!arrayBuffer43.detached) { new Uint8Array(arrayBuffer43).fill(0x55); };
} catch {}
try {
computePassEncoder78.setBindGroup(1, bindGroup194, []);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder13.insertDebugMarker('\u848c');
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let textureView438 = texture402.createView({dimension: '2d-array', format: 'astc-5x5-unorm', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder174.setBindGroup(2, bindGroup157);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, undefined);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let bindGroupLayout51 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 85,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let texture436 = device0.createTexture({size: [322, 2, 88], format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder91.setBindGroup(3, bindGroup205);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer219, 'uint32', 3_372, 233);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 22},
  aspect: 'all',
}, new Uint8Array(9_840).fill(123), /* required buffer size: 9_840 */
{offset: 336, bytesPerRow: 27, rowsPerImage: 22}, {width: 0, height: 0, depthOrArrayLayers: 17});
} catch {}
let texture437 = device0.createTexture({
  label: '\u{1feb9}\ubabd\u2c3c\u{1fc33}\u{1fe0c}\u480d',
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  mipLevelCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView439 = texture212.createView({label: '\u8338\u0247', mipLevelCount: 1});
try {
renderPassEncoder54.setBindGroup(3, bindGroup227);
} catch {}
try {
renderPassEncoder36.setBlendConstant({ r: -962.9, g: 204.1, b: 592.9, a: -513.2, });
} catch {}
try {
renderPassEncoder7.setVertexBuffer(5, buffer166, 2_404);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 96, new DataView(new ArrayBuffer(3579)), 1183, 388);
} catch {}
let texture438 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 129},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder186.setBindGroup(2, bindGroup130, new Uint32Array(4945), 671, 0);
} catch {}
try {
renderPassEncoder38.executeBundles([renderBundle42, renderBundle42]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture128,
  mipLevel: 0,
  origin: {x: 16, y: 1, z: 3},
  aspect: 'all',
}, new Uint8Array(323_845).fill(132), /* required buffer size: 323_845 */
{offset: 205, bytesPerRow: 186, rowsPerImage: 29}, {width: 57, height: 0, depthOrArrayLayers: 61});
} catch {}
let textureView440 = texture354.createView({baseMipLevel: 0, arrayLayerCount: 1});
let externalTexture63 = device0.importExternalTexture({source: videoFrame39, colorSpace: 'display-p3'});
try {
computePassEncoder41.setBindGroup(3, bindGroup204);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup30, new Uint32Array(1409), 270, 0);
} catch {}
try {
renderPassEncoder30.setStencilReference(222);
} catch {}
let videoFrame71 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte240m', transfer: 'bt2020_12bit'} });
try {
commandEncoder66.label = '\u07c8\u{1f950}\u62bf\u8c40\u88a4\ud093\ufab6\u85ab';
} catch {}
let texture439 = device0.createTexture({size: [104], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
let textureView441 = texture431.createView({aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder208.setBindGroup(2, bindGroup102);
} catch {}
let promise48 = device0.queue.onSubmittedWorkDone();
let bindGroupLayout52 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 100,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let bindGroup253 = device0.createBindGroup({layout: bindGroupLayout30, entries: [{binding: 82, resource: textureView1}]});
let texture440 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 77},
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder4.beginOcclusionQuery(269);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder31.executeBundles([renderBundle31]);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture441 = device0.createTexture({
  size: [13, 2, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder27.setIndexBuffer(buffer17, 'uint32', 3_984, 1_163);
} catch {}
let bindGroup254 = device0.createBindGroup({
  layout: bindGroupLayout20,
  entries: [
    {binding: 259, resource: {buffer: buffer1, offset: 1536, size: 685}},
    {binding: 27, resource: sampler219},
  ],
});
try {
renderPassEncoder22.setBindGroup(1, bindGroup64, new Uint32Array(10000), 2_958, 0);
} catch {}
try {
renderPassEncoder45.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder48.setScissorRect(4, 4, 5, 1);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer40, 'uint32', 332, 974);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(6, buffer54, 0);
} catch {}
try {
  await shaderModule6.getCompilationInfo();
} catch {}
try {
  await promise48;
} catch {}
let querySet57 = device0.createQuerySet({type: 'occlusion', count: 1396});
let textureView442 = texture40.createView({baseArrayLayer: 0});
try {
computePassEncoder146.setBindGroup(3, bindGroup150, new Uint32Array(1506), 64, 0);
} catch {}
try {
renderPassEncoder36.setBindGroup(3, bindGroup40);
} catch {}
try {
renderPassEncoder53.beginOcclusionQuery(26);
} catch {}
try {
renderPassEncoder55.setBlendConstant({ r: 999.2, g: 538.8, b: -949.0, a: 342.1, });
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer81, 'uint16', 580, 73);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
} catch {}
document.body.append(img1);
try {
globalThis.someLabel = renderBundleEncoder33.label;
} catch {}
let bindGroupLayout53 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 138,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 269,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 456,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let textureView443 = texture306.createView({baseArrayLayer: 0});
let texture442 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler247 = device0.createSampler({
  label: '\u1218\u805b\u12be\ua786\u0c3b\u99d1\u{1fb3f}\u{1fb07}\u6d77\u0ae2',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 6.829,
  lodMaxClamp: 44.30,
  compare: 'greater-equal',
  maxAnisotropy: 11,
});
try {
adapter0.label = '\u{1f73f}\u2db9\u{1fdda}';
} catch {}
let bindGroup255 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 268, resource: textureView80},
    {binding: 245, resource: textureView121},
    {binding: 41, resource: {buffer: buffer240, offset: 0, size: 2916}},
    {binding: 296, resource: textureView15},
    {binding: 115, resource: textureView117},
    {binding: 107, resource: textureView13},
    {binding: 9, resource: {buffer: buffer119, offset: 512, size: 134}},
    {binding: 38, resource: textureView43},
  ],
});
let texture443 = device0.createTexture({
  size: [161, 1, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture444 = device0.createTexture({
  size: [27, 4, 143],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder38.setBindGroup(1, bindGroup33, new Uint32Array(51), 8, 0);
} catch {}
try {
renderPassEncoder45.setBindGroup(2, bindGroup79, new Uint32Array(725), 0, 0);
} catch {}
try {
renderPassEncoder53.endOcclusionQuery();
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer34, 'uint32', 5_720, 5_789);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(3, buffer176, 3_724, 2_108);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 322, height: 2, depthOrArrayLayers: 1}
*/
{
  source: imageData22,
  origin: { x: 10, y: 0 },
  flipY: true,
}, {
  texture: texture400,
  mipLevel: 0,
  origin: {x: 51, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture445 = device0.createTexture({
  label: '\ua871\u376c\u{1fbd8}\ub6fc\ud3c0\u0edb\u42e2\ue4ef\u0e4c',
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler248 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 35.23,
  lodMaxClamp: 60.58,
});
try {
renderPassEncoder15.setScissorRect(3, 26, 0, 0);
} catch {}
let canvas10 = document.createElement('canvas');
let bindGroup256 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [
    {binding: 119, resource: textureView405},
    {binding: 230, resource: textureView420},
    {binding: 206, resource: textureView77},
    {binding: 74, resource: textureView333},
    {binding: 380, resource: textureView353},
    {binding: 196, resource: sampler11},
    {binding: 289, resource: textureView329},
    {binding: 220, resource: textureView284},
  ],
});
let buffer321 = device0.createBuffer({
  size: 20966,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView444 = texture109.createView({dimension: '2d-array'});
try {
computePassEncoder115.setBindGroup(3, bindGroup31, new Uint32Array(756), 364, 0);
} catch {}
try {
renderPassEncoder0.setViewport(11.501295290129725, 11.239004158440466, 9.195012477193421, 10.23290347458365, 0.33496554372975207, 0.4535206328502948);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(1, buffer319);
} catch {}
try {
  await promise44;
} catch {}
let bindGroup257 = device0.createBindGroup({layout: bindGroupLayout52, entries: [{binding: 100, resource: textureView128}]});
let buffer322 = device0.createBuffer({size: 1085, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let textureView445 = texture52.createView({baseArrayLayer: 23, arrayLayerCount: 7});
try {
computePassEncoder148.setBindGroup(1, bindGroup177, new Uint32Array(474), 36, 0);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup138);
} catch {}
try {
renderPassEncoder22.beginOcclusionQuery(134);
} catch {}
try {
renderPassEncoder22.endOcclusionQuery();
} catch {}
try {
buffer253.unmap();
} catch {}
let buffer323 = device0.createBuffer({size: 2706, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let texture446 = gpuCanvasContext16.getCurrentTexture();
try {
computePassEncoder59.setBindGroup(2, bindGroup141, new Uint32Array(305), 30, 0);
} catch {}
try {
renderPassEncoder34.executeBundles([renderBundle7]);
} catch {}
let textureView446 = texture408.createView({mipLevelCount: 1, baseArrayLayer: 19, arrayLayerCount: 1});
let sampler249 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 52.16,
  lodMaxClamp: 83.33,
});
try {
if (!arrayBuffer39.detached) { new Uint8Array(arrayBuffer39).fill(0x55); };
} catch {}
let textureView447 = texture242.createView({label: '\u{1f6e0}\u{1febd}\u7b75', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 12});
let renderBundleEncoder57 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4});
try {
computePassEncoder61.setBindGroup(2, bindGroup115);
} catch {}
try {
renderPassEncoder55.setBindGroup(3, bindGroup36, []);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer39, 'uint16', 3_856, 2_719);
} catch {}
try {
renderBundleEncoder57.setVertexBuffer(5, buffer220, 0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture407,
  mipLevel: 2,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(255).fill(237), /* required buffer size: 255 */
{offset: 255, rowsPerImage: 16}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame72 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt709', transfer: 'smpte170m'} });
try {
computePassEncoder137.setBindGroup(2, bindGroup8);
} catch {}
try {
computePassEncoder114.setBindGroup(0, bindGroup126, new Uint32Array(676), 20, 0);
} catch {}
try {
renderBundleEncoder57.setBindGroup(1, bindGroup222);
} catch {}
let buffer324 = device0.createBuffer({size: 3530, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView448 = texture401.createView({
  label: '\udf18\u{1f603}\u9b62\ua4a9',
  dimension: '2d',
  baseMipLevel: 0,
  baseArrayLayer: 6,
  arrayLayerCount: 1,
});
let renderBundleEncoder58 = device0.createRenderBundleEncoder({
  label: '\u{1f98c}\u{1fac2}\u{1fed9}\u9ca1\u53bf\ub3be\u2b40',
  colorFormats: ['r8uint'],
  depthStencilFormat: 'stencil8',
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle57 = renderBundleEncoder58.finish({});
try {
computePassEncoder7.setBindGroup(1, bindGroup155);
} catch {}
try {
renderPassEncoder44.beginOcclusionQuery(22);
} catch {}
try {
renderPassEncoder20.setViewport(8.087026693368456, 23.902121011032506, 23.519002681839005, 6.2187733832313175, 0.12375592371777955, 0.48330867685208945);
} catch {}
try {
renderBundleEncoder57.setBindGroup(3, bindGroup247);
} catch {}
try {
renderBundleEncoder57.setVertexBuffer(1, buffer164, 0, 889);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(5, buffer281, 188, 115);
} catch {}
try {
renderBundleEncoder57.setBindGroup(0, bindGroup85, new Uint32Array(1864), 141, 0);
} catch {}
await gc();
let videoFrame73 = new VideoFrame(canvas8, {timestamp: 0});
let buffer325 = device0.createBuffer({
  size: 502,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let querySet58 = device0.createQuerySet({type: 'occlusion', count: 19});
let texture447 = device0.createTexture({
  size: [55, 8, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder99.setBindGroup(2, bindGroup49, new Uint32Array(366), 20, 0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer137, 4, 1_469);
} catch {}
let buffer326 = device0.createBuffer({size: 2425, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let textureView449 = texture218.createView({dimension: '3d', mipLevelCount: 1, baseArrayLayer: 0});
let renderBundleEncoder59 = device0.createRenderBundleEncoder({
  label: '\u0859\u00c6\u62b1\u{1ffa1}\u1fe2\ue728\u4257\u{1f804}\uda2c',
  colorFormats: ['rg32float'],
  sampleCount: 4,
  depthReadOnly: false,
  stencilReadOnly: true,
});
let renderBundle58 = renderBundleEncoder57.finish();
try {
computePassEncoder136.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup151, new Uint32Array(2174), 57, 0);
} catch {}
try {
renderPassEncoder44.endOcclusionQuery();
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer3, 'uint32', 68, 7);
} catch {}
try {
renderBundleEncoder59.setVertexBuffer(6, undefined, 0, 1_379_149_205);
} catch {}
try {
buffer281.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup258 = device0.createBindGroup({layout: bindGroupLayout41, entries: [{binding: 137, resource: textureView368}]});
let renderBundle59 = renderBundleEncoder59.finish();
try {
computePassEncoder102.setBindGroup(1, bindGroup31);
} catch {}
try {
computePassEncoder94.setBindGroup(0, bindGroup135, new Uint32Array(3476), 331, 0);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup21);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); };
} catch {}
let sampler250 = device0.createSampler({
  label: '\u{1f6a4}\u0deb\u60d5\ud4ad\u4729\u{1fa60}\u0570\u{1ff03}\ub86d',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 5.677,
  lodMaxClamp: 46.21,
  maxAnisotropy: 5,
});
try {
computePassEncoder210.setBindGroup(2, bindGroup124, new Uint32Array(223), 100, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup104);
} catch {}
try {
device0.queue.writeBuffer(buffer250, 780, new BigUint64Array(2867), 74, 512);
} catch {}
document.body.prepend(canvas9);
try {
computePassEncoder216.setBindGroup(0, bindGroup202, new Uint32Array(798), 42, 0);
} catch {}
try {
computePassEncoder170.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder55.setIndexBuffer(buffer148, 'uint16', 1_670, 3_415);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(4, buffer150);
} catch {}
try {
gpuCanvasContext18.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup259 = device0.createBindGroup({layout: bindGroupLayout30, entries: [{binding: 82, resource: textureView197}]});
try {
renderPassEncoder46.setBindGroup(1, bindGroup7, new Uint32Array(1102), 82, 0);
} catch {}
document.body.prepend(canvas4);
let pipelineLayout28 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture448 = device0.createTexture({size: [13, 10, 16], dimension: '3d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_SRC});
let textureView450 = texture264.createView({format: 'r8uint'});
try {
renderPassEncoder10.executeBundles([renderBundle47]);
} catch {}
try {
device0.queue.writeBuffer(buffer299, 3240, new Int16Array(5279), 720, 16);
} catch {}
document.body.prepend(img1);
let buffer327 = device0.createBuffer({
  size: 5429,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
  mappedAtCreation: false,
});
let texture449 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 38},
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture450 = device0.createTexture({
  size: [55, 8, 8],
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView451 = texture83.createView({mipLevelCount: 1});
try {
renderPassEncoder34.setBindGroup(1, bindGroup125);
} catch {}
try {
buffer141.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 645, height: 4, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture66,
  mipLevel: 0,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture451 = device0.createTexture({size: [110, 16, 23], format: 'r8uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder93.setBindGroup(2, bindGroup253, new Uint32Array(2965), 275, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle28, renderBundle2]);
} catch {}
let bindGroup260 = device0.createBindGroup({layout: bindGroupLayout28, entries: [{binding: 423, resource: textureView1}]});
let buffer328 = device0.createBuffer({
  label: '\u8e03\u0a69\u{1ffe1}\u7be1\u{1f8bb}\u3df3\u01d9',
  size: 10660,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView452 = texture172.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder49.setBindGroup(1, bindGroup157);
} catch {}
try {
computePassEncoder27.setBindGroup(0, bindGroup194, new Uint32Array(1840), 436, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup102);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(6, buffer8, 0, 2_108);
} catch {}
try {
device0.queue.writeBuffer(buffer322, 28, new Int16Array(751), 121, 12);
} catch {}
await gc();
let offscreenCanvas12 = new OffscreenCanvas(324, 207);
try {
renderPassEncoder17.setStencilReference(2182);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer144, 'uint32', 48, 56);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(2, buffer316, 244);
} catch {}
try {
device0.queue.writeBuffer(buffer238, 856, new BigUint64Array(11756), 141, 116);
} catch {}
let promise49 = device0.queue.onSubmittedWorkDone();
let bindGroup261 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 31, resource: textureView208},
    {binding: 208, resource: textureView126},
    {binding: 159, resource: textureView254},
  ],
});
try {
renderPassEncoder18.setBlendConstant({ r: -934.0, g: 495.1, b: 89.15, a: 778.0, });
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer2);
} catch {}
let gpuCanvasContext19 = offscreenCanvas12.getContext('webgpu');
document.body.prepend(canvas10);
let bindGroup262 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 219, resource: textureView61}]});
let texture452 = device0.createTexture({
  size: [161, 1, 1],
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder2.setIndexBuffer(buffer304, 'uint16', 220, 103);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline3);
} catch {}
document.body.append(canvas8);
try {
renderPassEncoder46.setBindGroup(3, bindGroup244, []);
} catch {}
try {
renderPassEncoder7.setViewport(12.995962541643859, 29.305913343236444, 16.84879672727226, 4.636510025154932, 0.065224187140286, 0.6841753096627728);
} catch {}
let buffer329 = device0.createBuffer({
  size: 504,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView453 = texture367.createView({label: '\u{1fccd}\u{1fe98}\u2718\u4120\uacab', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 7});
try {
renderPassEncoder12.setStencilReference(440);
} catch {}
try {
computePassEncoder92.pushDebugGroup('\ua8f0');
} catch {}
let sampler251 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.651,
  maxAnisotropy: 19,
});
try {
computePassEncoder87.setBindGroup(2, bindGroup25, new Uint32Array(734), 38, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup145);
} catch {}
let buffer330 = device0.createBuffer({size: 1022, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let textureView454 = texture449.createView({label: '\u02d7\u4ab0\u0fe6\u{1fd06}\u6803\u5797\u8732', baseArrayLayer: 18, arrayLayerCount: 2});
try {
renderPassEncoder27.setBindGroup(2, bindGroup179);
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle29, renderBundle48]);
} catch {}
let textureView455 = texture451.createView({label: '\u{1fccb}\u2733\u780b\ud17a\u00ac\u08d8\ue5e5\u0fe9\ue116', arrayLayerCount: 6});
try {
renderPassEncoder34.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder92.popDebugGroup();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroupLayout54 = device0.createBindGroupLayout({
  entries: [
    {binding: 45, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
try {
computePassEncoder71.setBindGroup(2, bindGroup167);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer296, 'uint16', 686, 192);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(3, buffer187, 0);
} catch {}
try {
  await promise49;
} catch {}
let imageData50 = new ImageData(172, 124);
let texture453 = device0.createTexture({
  size: {width: 13, height: 10, depthOrArrayLayers: 16},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder32.setVertexBuffer(1, buffer15, 2_540, 144);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture286,
  mipLevel: 0,
  origin: {x: 237, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(35).fill(11), /* required buffer size: 35 */
{offset: 35}, {width: 80, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img2);
try {
externalTexture34.label = '\u009c\u6367\u{1fe05}\u08e1';
} catch {}
let bindGroup263 = device0.createBindGroup({
  layout: bindGroupLayout51,
  entries: [{binding: 40, resource: textureView398}, {binding: 85, resource: textureView314}],
});
try {
computePassEncoder134.setBindGroup(1, bindGroup22);
} catch {}
try {
computePassEncoder180.setBindGroup(0, bindGroup255, new Uint32Array(881), 86, 0);
} catch {}
try {
renderPassEncoder9.setBlendConstant({ r: -15.86, g: -133.7, b: -609.0, a: -34.94, });
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer315, 0, 28);
} catch {}
try {
device0.queue.writeBuffer(buffer66, 6352, new Float32Array(37819), 15805, 3408);
} catch {}
let buffer331 = device0.createBuffer({size: 24073, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let texture454 = gpuCanvasContext12.getCurrentTexture();
let textureView456 = texture182.createView({dimension: '1d'});
try {
renderPassEncoder12.setBlendConstant({ r: 998.4, g: 40.35, b: -966.9, a: -701.8, });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture289,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(45).fill(10), /* required buffer size: 45 */
{offset: 45, bytesPerRow: 58, rowsPerImage: 33}, {width: 12, height: 3, depthOrArrayLayers: 0});
} catch {}
let buffer332 = device0.createBuffer({
  label: '\u061c\u88e0\u8711\ud849\u00ef\u05c9\ud29f',
  size: 26284,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let texture455 = device0.createTexture({size: [322], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder118.setBindGroup(3, bindGroup249);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup93, new Uint32Array(1985), 74, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(4, buffer255, 40, 809);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 0, y: 29 },
  flipY: true,
}, {
  texture: texture164,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let bindGroup264 = device0.createBindGroup({layout: bindGroupLayout52, entries: [{binding: 100, resource: textureView290}]});
let buffer333 = device0.createBuffer({
  size: 18565,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
computePassEncoder20.setBindGroup(3, bindGroup239);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroupsIndirect(buffer121, 184); };
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle55, renderBundle55, renderBundle44, renderBundle48, renderBundle48]);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(3, buffer24);
} catch {}
let videoFrame74 = new VideoFrame(videoFrame40, {timestamp: 0});
let texture456 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder28.setBindGroup(1, bindGroup35);
} catch {}
try {
renderPassEncoder54.setIndexBuffer(buffer118, 'uint32', 828, 19);
} catch {}
try {
device0.queue.writeBuffer(buffer73, 88, new Float32Array(29), 0, 0);
} catch {}
let bindGroup265 = device0.createBindGroup({
  layout: bindGroupLayout51,
  entries: [{binding: 40, resource: textureView141}, {binding: 85, resource: textureView443}],
});
let sampler252 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 75.73,
  lodMaxClamp: 77.80,
  compare: 'less-equal',
  maxAnisotropy: 18,
});
try {
renderPassEncoder27.setBindGroup(3, bindGroup38);
} catch {}
try {
renderPassEncoder31.setBindGroup(3, bindGroup30, new Uint32Array(1842), 53, 0);
} catch {}
try {
renderPassEncoder52.setIndexBuffer(buffer3, 'uint32', 116, 18);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture444,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 14},
  aspect: 'all',
}, new Uint8Array(38).fill(88), /* required buffer size: 38 */
{offset: 38}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let renderBundleEncoder60 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], sampleCount: 4, stencilReadOnly: true});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 6, height: 1, depthOrArrayLayers: 39}
*/
{
  source: imageData18,
  origin: { x: 25, y: 1 },
  flipY: true,
}, {
  texture: texture334,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView457 = texture51.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 3});
try {
renderPassEncoder1.setBindGroup(2, bindGroup245);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(8899), 4_567, 0);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(4, buffer180, 2_568, 5_519);
} catch {}
try {
buffer39.unmap();
} catch {}
try {
computePassEncoder114.insertDebugMarker('\u{1fa51}');
} catch {}
try {
computePassEncoder110.setBindGroup(3, bindGroup154);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder40.setBindGroup(0, bindGroup227);
} catch {}
try {
renderBundleEncoder60.setIndexBuffer(buffer205, 'uint16', 318, 12);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(5, buffer206, 0, 1_082);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 148, new BigUint64Array(13871), 3173, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup55, new Uint32Array(2127), 25, 0);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer74, 'uint32', 340, 411);
} catch {}
try {
renderPassEncoder52.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder60.setBindGroup(1, bindGroup97);
} catch {}
try {
renderBundleEncoder60.setBindGroup(1, bindGroup78, new Uint32Array(86), 26, 0);
} catch {}
let textureView458 = texture256.createView({format: 'rgb10a2uint'});
try {
renderPassEncoder18.setBindGroup(2, bindGroup231, new Uint32Array(1019), 5, 0);
} catch {}
let imageData51 = new ImageData(68, 12);
let buffer334 = device0.createBuffer({size: 2263, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture457 = device0.createTexture({
  size: [1290],
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder28.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder60.setBindGroup(2, bindGroup199, new Uint32Array(1156), 206, 0);
} catch {}
try {
renderBundleEncoder60.setIndexBuffer(buffer34, 'uint16', 114, 5_359);
} catch {}
let bindGroup266 = device0.createBindGroup({layout: bindGroupLayout29, entries: [{binding: 166, resource: textureView75}]});
let textureView459 = texture303.createView({});
try {
computePassEncoder38.setBindGroup(3, bindGroup76);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroupsIndirect(buffer210, 424); };
} catch {}
try {
renderPassEncoder0.setViewport(28.467503129012215, 20.76276617470471, 7.1233735173430945, 5.785239645277905, 0.2907716301271651, 0.5793573649921511);
} catch {}
let videoFrame75 = videoFrame22.clone();
let texture458 = device0.createTexture({
  size: {width: 55, height: 8, depthOrArrayLayers: 312},
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder9.setBindGroup(2, bindGroup13, new Uint32Array(824), 11, 0);
} catch {}
let texture459 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 43},
  sampleCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder28.setBindGroup(2, bindGroup166);
} catch {}
try {
renderPassEncoder28.setBindGroup(2, bindGroup17, new Uint32Array(2346), 422, 0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle4, renderBundle0]);
} catch {}
try {
renderBundleEncoder60.setBindGroup(0, bindGroup34, new Uint32Array(1343), 133, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 1, y: 8, z: 0},
  aspect: 'all',
}, new Uint8Array(126).fill(199), /* required buffer size: 126 */
{offset: 126, bytesPerRow: 201}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture460 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 1},
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView460 = texture360.createView({aspect: 'all'});
let externalTexture64 = device0.importExternalTexture({label: '\u{1fce1}\uf41d\u2a7f\u{1fc2e}\udeaa\u1b3f\uf7ba\u3d11\u{1f6a6}\u2255', source: videoFrame59});
try {
renderPassEncoder22.setBindGroup(2, bindGroup257, new Uint32Array(684), 73, 0);
} catch {}
try {
renderPassEncoder49.executeBundles([renderBundle38, renderBundle0, renderBundle14, renderBundle14]);
} catch {}
try {
renderBundleEncoder60.setBindGroup(2, bindGroup23);
} catch {}
try {
renderBundleEncoder60.setIndexBuffer(buffer205, 'uint32', 12, 218);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(1, buffer259, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup224);
} catch {}
try {
renderPassEncoder43.executeBundles([renderBundle27]);
} catch {}
try {
renderPassEncoder28.setBlendConstant({ r: 402.7, g: -872.7, b: -838.8, a: 974.3, });
} catch {}
try {
renderPassEncoder27.setVertexBuffer(7, buffer209);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture202,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(0).fill(133), /* required buffer size: 0 */
{offset: 0}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer335 = device0.createBuffer({size: 44941, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let texture461 = device0.createTexture({
  size: [13, 2, 78],
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle60 = renderBundleEncoder60.finish({});
try {
computePassEncoder142.setBindGroup(2, bindGroup103);
} catch {}
try {
renderPassEncoder44.setPipeline(pipeline3);
} catch {}
let buffer336 = device0.createBuffer({size: 17761, usage: GPUBufferUsage.QUERY_RESOLVE});
let sampler253 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 98.41,
  lodMaxClamp: 99.24,
  compare: 'less',
  maxAnisotropy: 9,
});
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder43.setBindGroup(3, bindGroup200, new Uint32Array(2035), 525, 0);
} catch {}
let sampler254 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 16.63,
  lodMaxClamp: 55.07,
});
try {
computePassEncoder177.setBindGroup(3, bindGroup146);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroupsIndirect(buffer32, 4_508); };
} catch {}
try {
renderPassEncoder32.setBindGroup(3, bindGroup99, new Uint32Array(5804), 488, 0);
} catch {}
try {
renderPassEncoder52.end();
} catch {}
try {
renderPassEncoder45.executeBundles([renderBundle0, renderBundle47, renderBundle6]);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer321, 'uint16', 4_250, 1_434);
} catch {}
try {
gpuCanvasContext19.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame56,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture191,
  mipLevel: 0,
  origin: {x: 2, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup267 = device0.createBindGroup({
  label: '\u070c\u9176\u0084\u{1f74c}\u1f8b\u45f7\u3051\u9c96\u{1fcfe}\u{1fbcf}\uc0be',
  layout: bindGroupLayout49,
  entries: [{binding: 60, resource: sampler181}],
});
let texture462 = device0.createTexture({size: [27, 4, 1], format: 'r16float', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder114.setBindGroup(3, bindGroup84);
} catch {}
try {
computePassEncoder94.setBindGroup(3, bindGroup10, new Uint32Array(512), 286, 0);
} catch {}
try {
renderPassEncoder46.setBindGroup(3, bindGroup34);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup170, new Uint32Array(461), 302, 0);
} catch {}
document.body.prepend(img1);
let textureView461 = texture31.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder35.setBindGroup(3, bindGroup30);
} catch {}
try {
computePassEncoder24.setBindGroup(2, bindGroup87, new Uint32Array(1188), 95, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture76,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(38).fill(48), /* required buffer size: 38 */
{offset: 38}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame76 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'log'} });
let commandBuffer8 = commandEncoder83.finish();
let texture463 = device0.createTexture({
  size: [13],
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView462 = texture98.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder2.executeBundles([renderBundle26, renderBundle47, renderBundle2]);
} catch {}
try {
computePassEncoder214.setBindGroup(3, bindGroup89, new Uint32Array(1271), 526, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup134, new Uint32Array(4710), 1_019, 0);
} catch {}
let imageData52 = new ImageData(40, 16);
let bindGroup268 = device0.createBindGroup({
  label: '\u{1f67c}\u000e\u0636\ub50f\u9418\u0695\u5f86\ue519\ufbb8',
  layout: bindGroupLayout14,
  entries: [
    {binding: 7, resource: {buffer: buffer89, offset: 5376, size: 11306}},
    {binding: 71, resource: {buffer: buffer77, offset: 512, size: 2076}},
  ],
});
let buffer337 = device0.createBuffer({size: 6140, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder264 = device0.createCommandEncoder();
let computePassEncoder234 = commandEncoder264.beginComputePass({});
let sampler255 = device0.createSampler({
  label: '\u{1f796}\ufa73\ub60f\u062a\u7ec5\u80b2',
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 93.88,
});
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroups(1); };
} catch {}
let textureView463 = texture329.createView({dimension: '2d-array'});
let sampler256 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 40.54,
  lodMaxClamp: 52.35,
  compare: 'not-equal',
});
try {
computePassEncoder80.setBindGroup(0, bindGroup94);
} catch {}
try {
computePassEncoder109.setBindGroup(1, bindGroup264, new Uint32Array(1520), 479, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, buffer300, 0, 189);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
let gpuCanvasContext20 = canvas10.getContext('webgpu');
let sampler257 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 28.02,
  lodMaxClamp: 51.15,
});
try {
computePassEncoder234.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle55]);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 60, new BigUint64Array(2499), 197, 16);
} catch {}
let textureView464 = texture110.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder18.setBindGroup(3, bindGroup168);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer122, 'uint32', 204, 726);
} catch {}
let buffer338 = device0.createBuffer({
  label: '\u{1ff6d}\uc622\u073c',
  size: 11128,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let textureView465 = texture327.createView({baseArrayLayer: 70, arrayLayerCount: 1});
let textureView466 = texture14.createView({aspect: 'all', arrayLayerCount: 1});
try {
computePassEncoder50.setBindGroup(3, bindGroup112);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 27, height: 4, depthOrArrayLayers: 156}
*/
{
  source: videoFrame33,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 30},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let textureView467 = texture184.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 6});
try {
computePassEncoder196.setBindGroup(2, bindGroup59, new Uint32Array(641), 63, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroupsIndirect(buffer204, 44); };
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup239, new Uint32Array(3960), 646, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageBitmap15 = await createImageBitmap(imageData19);
try {
adapter0.label = '\u{1fc92}\u{1fb90}';
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup229, new Uint32Array(1377), 928, 0);
} catch {}
try {
renderPassEncoder42.executeBundles([renderBundle4, renderBundle6]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer208, 'uint32', 80, 222);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture409,
  mipLevel: 0,
  origin: {x: 455, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(182).fill(80), /* required buffer size: 182 */
{offset: 182}, {width: 53, height: 1, depthOrArrayLayers: 0});
} catch {}
await gc();
let texture464 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 27},
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView468 = texture195.createView({label: '\u{1f9eb}\u03d7\u0cf0\u8d6e\u8595'});
try {
renderPassEncoder47.setBindGroup(2, bindGroup161, new Uint32Array(332), 24, 0);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(1, buffer42);
} catch {}
try {
gpuCanvasContext14.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer279, 4292, new DataView(new ArrayBuffer(16200)));
} catch {}
let imageData53 = new ImageData(100, 12);
let bindGroupLayout55 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 198,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 253,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {binding: 57, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 183,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 112,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 199,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 166, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 184,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '3d' },
    },
  ],
});
let bindGroup269 = device0.createBindGroup({
  layout: bindGroupLayout25,
  entries: [
    {binding: 22, resource: textureView141},
    {binding: 26, resource: {buffer: buffer83, offset: 512, size: 768}},
  ],
});
let texture465 = device0.createTexture({
  size: {width: 26, height: 20, depthOrArrayLayers: 32},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder135.setBindGroup(3, bindGroup179, new Uint32Array(123), 21, 0);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder46.setVertexBuffer(4, buffer158, 1_388, 2_317);
} catch {}
try {
renderPassEncoder27.insertDebugMarker('\u69f6');
} catch {}
let promise50 = device0.queue.onSubmittedWorkDone();
let pipelineLayout29 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer339 = device0.createBuffer({size: 5643, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture466 = device0.createTexture({
  size: {width: 104, height: 80, depthOrArrayLayers: 128},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture467 = device0.createTexture({
  size: [110],
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView469 = texture89.createView({mipLevelCount: 1});
try {
computePassEncoder71.setBindGroup(1, bindGroup33, new Uint32Array(1308), 146, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder17.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup99);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(3, buffer55, 0);
} catch {}
let promise51 = device0.queue.onSubmittedWorkDone();
try {
  await promise51;
} catch {}
let buffer340 = device0.createBuffer({
  label: '\u091a\u497a\u{1f974}\u4722\uacd3\u0389\ua6d6\u08b0\u0c41',
  size: 11774,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView470 = texture465.createView({});
try {
computePassEncoder49.setBindGroup(1, bindGroup61);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup192);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup95, new Uint32Array(617), 4, 0);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let textureView471 = texture297.createView({label: '\u012e\u0f0c\u04bd\u1350\u54a9'});
let textureView472 = texture9.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 57});
try {
renderPassEncoder11.executeBundles([renderBundle17, renderBundle18]);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(3, buffer30, 0, 1_068);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let bindGroup270 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 31, resource: textureView309}]});
try {
computePassEncoder64.setBindGroup(2, bindGroup56);
} catch {}
try {
renderPassEncoder30.setBindGroup(2, bindGroup246);
} catch {}
try {
renderPassEncoder51.executeBundles([renderBundle29]);
} catch {}
await gc();
let buffer341 = device0.createBuffer({
  label: '\u{1f847}\uc954\u6898\u4b28\u6c7d\u{1f600}\u384b\u{1ff0f}',
  size: 17530,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let texture468 = device0.createTexture({size: [2, 2, 27], format: 'rg16uint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder17.setScissorRect(4, 3, 5, 7);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer256, 'uint16', 490, 6_713);
} catch {}
let arrayBuffer44 = buffer162.getMappedRange(272, 20);
try {
device0.queue.writeBuffer(buffer183, 1688, new Float32Array(5811), 159, 348);
} catch {}
try {
if (!arrayBuffer40.detached) { new Uint8Array(arrayBuffer40).fill(0x55); };
} catch {}
let videoFrame77 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte240m', transfer: 'iec61966-2-1'} });
let bindGroup271 = device0.createBindGroup({
  layout: bindGroupLayout44,
  entries: [
    {binding: 223, resource: {buffer: buffer52, offset: 0, size: 1455}},
    {binding: 464, resource: textureView117},
    {binding: 129, resource: textureView77},
  ],
});
let buffer342 = device0.createBuffer({label: '\ubbca\u0b99\u0fd5\u0049', size: 32272, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let texture469 = device0.createTexture({
  size: {width: 27, height: 4, depthOrArrayLayers: 37},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
{ clearResourceUsages(device0, computePassEncoder180); computePassEncoder180.dispatchWorkgroupsIndirect(buffer152, 3_824); };
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer101, 'uint32', 208, 162);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(7, buffer137, 0, 170);
} catch {}
let arrayBuffer45 = buffer90.getMappedRange(8400, 0);
try {
gpuCanvasContext17.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 2, depthOrArrayLayers: 41}
*/
{
  source: videoFrame33,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture204,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 10},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame78 = new VideoFrame(offscreenCanvas4, {timestamp: 0});
try {
adapter0.label = '\u03cb\u57ea\u625e';
} catch {}
try {
globalThis.someLabel = computePassEncoder146.label;
} catch {}
let pipelineLayout30 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView473 = texture59.createView({dimension: '2d', mipLevelCount: 1});
let textureView474 = texture274.createView({dimension: '2d-array', baseMipLevel: 0});
let sampler258 = device0.createSampler({
  label: '\u05f1\ue342\u020b\u0435\u0af0\uad83\u0d66\uf0d2\u657e\ud1ec\udf3a',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.963,
});
try {
renderPassEncoder7.setBindGroup(3, bindGroup205, new Uint32Array(2996), 742, 0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle39]);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline1);
} catch {}
let arrayBuffer46 = buffer162.getMappedRange(96, 16);
try {
computePassEncoder114.pushDebugGroup('\u0f5f');
} catch {}
try {
gpuCanvasContext16.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let textureView475 = texture130.createView({baseMipLevel: 0, baseArrayLayer: 3, arrayLayerCount: 4});
let sampler259 = device0.createSampler({
  label: '\u7d54\u{1fd27}\u090a\u0917',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.32,
  lodMaxClamp: 91.70,
  maxAnisotropy: 2,
});
try {
renderPassEncoder25.setIndexBuffer(buffer286, 'uint32', 2_552, 824);
} catch {}
try {
buffer250.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let querySet59 = device0.createQuerySet({type: 'occlusion', count: 172});
try {
computePassEncoder180.end();
} catch {}
try {
renderPassEncoder37.setBindGroup(0, bindGroup124);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder44.setVertexBuffer(5, buffer166, 0, 149);
} catch {}
try {
commandEncoder221.copyBufferToBuffer(buffer325, 28, buffer263, 448, 160);
} catch {}
try {
commandEncoder221.copyTextureToTexture({
  texture: texture255,
  mipLevel: 0,
  origin: {x: 1100, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture140,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 45, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder114.popDebugGroup();
} catch {}
try {
computePassEncoder85.insertDebugMarker('\u{1ffa8}');
} catch {}
let texture470 = device0.createTexture({
  size: {width: 110},
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView476 = texture23.createView({dimension: '2d', baseArrayLayer: 1});
try {
renderPassEncoder3.setBindGroup(2, bindGroup100);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline3);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandBuffer9 = commandEncoder221.finish();
let textureView477 = texture395.createView({format: 'rg16uint', arrayLayerCount: 1});
try {
renderPassEncoder42.setBindGroup(1, bindGroup110, new Uint32Array(46), 5, 0);
} catch {}
try {
renderPassEncoder44.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer16, 'uint16', 936, 1_223);
} catch {}
try {
device0.queue.submit([commandBuffer9]);
} catch {}
try {
  await promise50;
} catch {}
let commandEncoder265 = device0.createCommandEncoder({});
let querySet60 = device0.createQuerySet({type: 'occlusion', count: 664});
let computePassEncoder235 = commandEncoder265.beginComputePass({});
try {
computePassEncoder50.setBindGroup(3, bindGroup58);
} catch {}
try {
computePassEncoder212.setBindGroup(0, bindGroup157, new Uint32Array(3978), 391, 0);
} catch {}
try {
computePassEncoder235.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup92, []);
} catch {}
try {
renderPassEncoder44.endOcclusionQuery();
} catch {}
try {
renderPassEncoder49.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer179, 'uint32', 1_508, 48);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture181,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(113).fill(158), /* required buffer size: 113 */
{offset: 113}, {width: 50, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView478 = texture408.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 27, arrayLayerCount: 1});
let sampler260 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 90.39,
  lodMaxClamp: 99.10,
  compare: 'less-equal',
  maxAnisotropy: 6,
});
try {
computePassEncoder143.setBindGroup(1, bindGroup260, new Uint32Array(381), 154, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle14]);
} catch {}
try {
renderPassEncoder55.setIndexBuffer(buffer91, 'uint32', 64, 1_927);
} catch {}
let texture471 = device0.createTexture({
  label: '\ue46f\u157d\u0588\u4b24',
  size: {width: 161, height: 1, depthOrArrayLayers: 15},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler261 = device0.createSampler({
  label: '\u064b\u{1fc30}\u02a5\ubc11\u0e0f\uf33c\u18ca',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 52.40,
  lodMaxClamp: 67.24,
  maxAnisotropy: 8,
});
try {
renderPassEncoder9.setBindGroup(0, bindGroup134);
} catch {}
try {
renderPassEncoder13.setBlendConstant({ r: -544.3, g: -712.9, b: -952.4, a: -549.0, });
} catch {}
let buffer343 = device0.createBuffer({
  size: 3426,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView479 = texture466.createView({});
let texture472 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder14.beginOcclusionQuery(82);
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle48]);
} catch {}
try {
renderPassEncoder27.setViewport(26.046625021881724, 5.809089796720843, 9.487819117122454, 0.18737268367401666, 0.0349356660983291, 0.9264789871521355);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer141, 'uint32', 6_568, 278);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer344 = device0.createBuffer({
  label: '\u89dc\u{1f95e}\u224c\u5d5e\ub93d\u{1ff85}\u9329',
  size: 2219,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView480 = texture21.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 5, arrayLayerCount: 6});
try {
renderPassEncoder36.setIndexBuffer(buffer331, 'uint16', 6_360, 673);
} catch {}
try {
device0.queue.writeBuffer(buffer306, 592, new Int16Array(7892), 121, 320);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let sampler262 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 54.81,
  lodMaxClamp: 81.22,
  maxAnisotropy: 13,
});
try {
computePassEncoder145.setBindGroup(0, bindGroup215, []);
} catch {}
try {
renderPassEncoder44.beginOcclusionQuery(8);
} catch {}
let texture473 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 129},
  mipLevelCount: 2,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView481 = texture396.createView({mipLevelCount: 1, baseArrayLayer: 0});
let sampler263 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 29.57,
  lodMaxClamp: 41.40,
  maxAnisotropy: 5,
});
let externalTexture65 = device0.importExternalTexture({label: '\u5d5f\u48aa\ufd26\ufd43', source: videoFrame57, colorSpace: 'display-p3'});
try {
computePassEncoder129.setBindGroup(2, bindGroup239, new Uint32Array(1022), 532, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup229);
} catch {}
try {
renderPassEncoder45.setBindGroup(2, bindGroup184, new Uint32Array(456), 24, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer207, 'uint32', 140, 8);
} catch {}
let textureView482 = texture415.createView({});
let sampler264 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMinClamp: 67.28,
  lodMaxClamp: 86.58,
});
try {
computePassEncoder199.setBindGroup(1, bindGroup61, new Uint32Array(1281), 246, 0);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer313, 'uint16', 2_878, 672);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline1);
} catch {}
let bindGroupLayout56 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 86,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 205,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 440,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 64,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let textureView483 = texture161.createView({dimension: 'cube', aspect: 'all', mipLevelCount: 1});
let texture474 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder33.setBindGroup(3, bindGroup50);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer84, 'uint16', 20_580, 2_432);
} catch {}
let videoFrame79 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'iec61966-2-1'} });
let bindGroupLayout57 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 506,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 107,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let texture475 = device0.createTexture({
  size: {width: 55, height: 8, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView484 = texture195.createView({});
let textureView485 = texture357.createView({format: 'rg32sint', arrayLayerCount: 5});
let textureView486 = texture274.createView({label: '\udefb\u{1f9bc}\ufa0c\u15c8\u2e62\u{1fb5c}\u5e1c\u0f26', arrayLayerCount: 1});
let sampler265 = device0.createSampler({
  label: '\u7453\u{1fe27}\ue967\u{1f9f3}\u0bd9\uc7e9',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 23.18,
  lodMaxClamp: 41.72,
  maxAnisotropy: 2,
});
try {
renderPassEncoder9.setBindGroup(0, bindGroup96, new Uint32Array(287), 111, 0);
} catch {}
try {
renderPassEncoder9.draw(130, 2, 1_174_692_438, 3);
} catch {}
try {
renderPassEncoder9.drawIndexed(19, 1, 10, 450_041_070);
} catch {}
try {
renderPassEncoder51.setIndexBuffer(buffer223, 'uint32', 52, 85);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer224, 0, 890);
} catch {}
let bindGroup272 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 28, resource: textureView98}, {binding: 162, resource: sampler154}],
});
let texture476 = gpuCanvasContext7.getCurrentTexture();
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.draw(213, 1, 268_326_060);
} catch {}
try {
renderPassEncoder9.drawIndexed(28, 2, 0, 565_293_921, 2);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer136, 'uint16', 3_834, 3_007);
} catch {}
try {
computePassEncoder157.pushDebugGroup('\u8fc3');
} catch {}
try {
gpuCanvasContext15.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
await gc();
let bindGroup273 = device0.createBindGroup({
  label: '\u2473\u{1fe2f}\u{1f934}\u926b',
  layout: bindGroupLayout0,
  entries: [
    {binding: 285, resource: {buffer: buffer75, offset: 8704, size: 4433}},
    {binding: 37, resource: textureView5},
  ],
});
let texture477 = device0.createTexture({
  size: [161, 1, 17],
  sampleCount: 1,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder152.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup238);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(6, buffer37, 0, 2_464);
} catch {}
try {
computePassEncoder157.popDebugGroup();
} catch {}
try {
if (!arrayBuffer26.detached) { new Uint8Array(arrayBuffer26).fill(0x55); };
} catch {}
let imageData54 = new ImageData(4, 96);
let texture478 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 19},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder115.setBindGroup(0, bindGroup127);
} catch {}
try {
renderPassEncoder44.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.setScissorRect(13, 0, 20, 14);
} catch {}
try {
renderPassEncoder9.draw(3, 0, 415_915_709, 2);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer335, 'uint32', 17_448, 2_681);
} catch {}
let textureView487 = texture266.createView({});
let externalTexture66 = device0.importExternalTexture({source: videoFrame9, colorSpace: 'srgb'});
try {
renderPassEncoder35.setScissorRect(2, 6, 0, 10);
} catch {}
try {
renderPassEncoder9.drawIndexed(27, 0, 3, 565_028_863, 12);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer17, 316);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer334, 276);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer35, 'uint32', 164, 1_733);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder46.setVertexBuffer(6, buffer40);
} catch {}
try {
buffer286.unmap();
} catch {}
let promise52 = device0.queue.onSubmittedWorkDone();
try {
  await promise52;
} catch {}
let textureView488 = texture334.createView({dimension: '3d', mipLevelCount: 1});
try {
renderPassEncoder9.drawIndexed(1, 1, 7, 586_782_239, 5);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer286, 'uint16', 2_332, 442);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let promise53 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 110, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData20,
  origin: { x: 34, y: 0 },
  flipY: true,
}, {
  texture: texture237,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let videoFrame80 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'film', transfer: 'smpteSt4281'} });
let sampler266 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge', lodMinClamp: 68.26, lodMaxClamp: 87.75});
try {
renderPassEncoder9.draw(348, 1, 2_049_321_696, 5);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 3, 82, 435_905_114, 6);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer251, 1_196);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer159, 4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture423,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 47},
  aspect: 'all',
}, new Uint8Array(96).fill(40), /* required buffer size: 96 */
{offset: 96, bytesPerRow: 54}, {width: 0, height: 26, depthOrArrayLayers: 0});
} catch {}
let bindGroup274 = device0.createBindGroup({
  layout: bindGroupLayout36,
  entries: [
    {binding: 50, resource: textureView353},
    {binding: 105, resource: {buffer: buffer172, offset: 3072, size: 2945}},
    {binding: 35, resource: textureView304},
    {binding: 140, resource: {buffer: buffer52, offset: 0, size: 1376}},
    {binding: 170, resource: textureView117},
  ],
});
let texture479 = device0.createTexture({
  size: {width: 322, height: 2, depthOrArrayLayers: 217},
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView489 = texture299.createView({});
try {
renderPassEncoder32.setIndexBuffer(buffer256, 'uint32', 3_460, 1_541);
} catch {}
try {
  await shaderModule8.getCompilationInfo();
} catch {}
let arrayBuffer47 = buffer305.getMappedRange(24, 0);
let textureView490 = texture271.createView({dimension: '2d-array'});
try {
{ clearResourceUsages(device0, computePassEncoder115); computePassEncoder115.dispatchWorkgroupsIndirect(buffer325, 228); };
} catch {}
try {
renderPassEncoder27.setViewport(37.22135664834331, 4.345563127789582, 12.588065020163665, 0.05077160030731271, 0.44204718175798197, 0.6570186174846816);
} catch {}
try {
renderPassEncoder9.drawIndexed(34, 6, 0, 137_760_385, 1);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer52, 460);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer290, 132);
} catch {}
try {
  await promise53;
} catch {}
let imageData55 = new ImageData(32, 16);
let texture480 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView491 = texture56.createView({dimension: '2d', baseArrayLayer: 22});
try {
computePassEncoder181.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder53.setBindGroup(0, bindGroup184);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer20, 2_388);
} catch {}
let texture481 = device0.createTexture({
  size: [27, 4, 4],
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView492 = texture0.createView({label: '\u06db\uf878\u{1fc3f}\u2eac\uf7ef\u8a4e\u3161', baseArrayLayer: 0});
try {
computePassEncoder235.setBindGroup(0, bindGroup134, []);
} catch {}
try {
renderPassEncoder29.setBindGroup(0, bindGroup263);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 2, 15, -1_948_884_085, 5);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer293, 'uint16', 568, 992);
} catch {}
try {
device0.queue.writeBuffer(buffer121, 516, new Int16Array(15912), 2802, 368);
} catch {}
let canvas11 = document.createElement('canvas');
let texture482 = device0.createTexture({
  size: [645, 4, 1],
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder51.setBindGroup(3, bindGroup0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder115); computePassEncoder115.dispatchWorkgroupsIndirect(buffer35, 308); };
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(30);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder46.executeBundles([renderBundle55, renderBundle27, renderBundle44, renderBundle48, renderBundle42]);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline3);
} catch {}
try {
buffer48.unmap();
} catch {}
let videoFrame81 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'bt2020_12bit'} });
let texture483 = device0.createTexture({size: [322], dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder27.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer313, 108);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer78, 500);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer148, 'uint16', 10_250, 1_588);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(5, buffer100, 0);
} catch {}
try {
computePassEncoder118.setBindGroup(3, bindGroup202, new Uint32Array(498), 0, 0);
} catch {}
try {
renderPassEncoder42.setScissorRect(13, 12, 6, 0);
} catch {}
try {
renderPassEncoder9.draw(89, 2, 44_207_601);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer75, 0);
} catch {}
let buffer345 = device0.createBuffer({size: 238, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let textureView493 = texture354.createView({dimension: '2d-array'});
try {
renderPassEncoder38.setBindGroup(1, bindGroup204, new Uint32Array(1148), 191, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer261, 92);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
});
} catch {}
let gpuCanvasContext21 = canvas11.getContext('webgpu');
try {
computePassEncoder112.setBindGroup(3, bindGroup141);
} catch {}
try {
computePassEncoder54.setBindGroup(3, bindGroup4, new Uint32Array(202), 51, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(5, 0, 16, 61_531_466, 2);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer10, 1_020);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer342, 'uint16', 172, 3_300);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer300, 0);
} catch {}
try {
gpuCanvasContext20.unconfigure();
} catch {}
let bindGroup275 = device0.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 30, resource: textureView109}]});
try {
renderPassEncoder9.drawIndexed(14, 13, 0, 151_644_632, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer343, 112);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer74, 'uint32', 116, 390);
} catch {}
try {
device0.queue.writeBuffer(buffer344, 460, new Int16Array(525), 181, 184);
} catch {}
try {
computePassEncoder25.setBindGroup(2, bindGroup223);
} catch {}
try {
renderPassEncoder9.draw(32, 0, 303_986_640, 2);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer118, 84);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(2, buffer78, 6_496, 4_165);
} catch {}
let buffer346 = device0.createBuffer({label: '\ud54b\u06a5', size: 1130, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
computePassEncoder20.setBindGroup(2, bindGroup89, new Uint32Array(2074), 88, 0);
} catch {}
try {
computePassEncoder70.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup204, []);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer54, 92);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, buffer119, 1_040, 6_087);
} catch {}
try {
buffer99.unmap();
} catch {}
let bindGroup276 = device0.createBindGroup({
  layout: bindGroupLayout46,
  entries: [
    {binding: 9, resource: textureView175},
    {binding: 395, resource: {buffer: buffer20, offset: 512, size: 2820}},
    {binding: 152, resource: textureView427},
    {binding: 109, resource: textureView105},
    {binding: 102, resource: {buffer: buffer342, offset: 6144}},
  ],
});
let sampler267 = device0.createSampler({
  label: '\u1494\u{1f85b}\u01ac\u1b81\ue0eb\u7d29',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.94,
  lodMaxClamp: 41.91,
  maxAnisotropy: 14,
});
try {
computePassEncoder116.setBindGroup(1, bindGroup72, new Uint32Array(450), 47, 0);
} catch {}
try {
renderPassEncoder9.draw(131, 3, 2_460_572_221, 1);
} catch {}
try {
renderPassEncoder9.drawIndexed(42, 1, 24, 620_137_745, 5);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer7, 108);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer256, 4_208);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 27}
*/
{
  source: imageData27,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture205,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup277 = device0.createBindGroup({
  label: '\u1a74\u0a84\u{1fe74}\u61e3\u26fa\ueb36\u0a08\uea45',
  layout: bindGroupLayout40,
  entries: [{binding: 470, resource: {buffer: buffer344, offset: 0, size: 372}}],
});
let buffer347 = device0.createBuffer({
  size: 16452,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView494 = texture420.createView({label: '\ua153\u1c2c\uf438\u31d8\u5cf6\ub40d', dimension: '2d', format: 'r32uint', baseArrayLayer: 2});
let textureView495 = texture104.createView({dimension: '2d', baseArrayLayer: 18});
try {
computePassEncoder96.setBindGroup(3, bindGroup85, new Uint32Array(22), 1, 0);
} catch {}
try {
renderPassEncoder9.setScissorRect(4, 12, 23, 2);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer308, 1_120);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer242, 'uint32', 464, 464);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
computePassEncoder105.insertDebugMarker('\uc1c6');
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let bindGroupLayout58 = device0.createBindGroupLayout({
  label: '\ub719\ue9e3\uda83\u{1f8a6}\ub09e\u{1fa0e}',
  entries: [
    {
      binding: 44,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 199,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let renderBundleEncoder61 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let sampler268 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 78.75,
  maxAnisotropy: 5,
});
try {
computePassEncoder84.setBindGroup(3, bindGroup55, new Uint32Array(163), 8, 0);
} catch {}
try {
computePassEncoder74.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.draw(21, 10, 2_471_915_349, 1);
} catch {}
try {
renderPassEncoder9.drawIndexed(4, 2, 41, 373_389_460);
} catch {}
try {
renderBundleEncoder61.setBindGroup(2, bindGroup186);
} catch {}
try {
renderBundleEncoder61.setBindGroup(0, bindGroup9, new Uint32Array(830), 93, 0);
} catch {}
await gc();
let buffer348 = device0.createBuffer({
  size: 9924,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let renderBundleEncoder62 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4});
let renderBundle61 = renderBundleEncoder61.finish();
let sampler269 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.71,
  compare: 'less',
});
try {
renderPassEncoder1.setBindGroup(0, bindGroup66);
} catch {}
try {
renderPassEncoder55.setBindGroup(3, bindGroup94, new Uint32Array(2676), 1_404, 0);
} catch {}
try {
renderPassEncoder27.setBlendConstant({ r: 471.5, g: -345.2, b: -418.0, a: 92.16, });
} catch {}
try {
renderBundleEncoder62.setIndexBuffer(buffer102, 'uint16', 782, 12_529);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
renderPassEncoder9.draw(319, 1, 121_762_177, 4);
} catch {}
try {
renderPassEncoder9.drawIndexed(46, 1, 65, -2_114_911_176, 13);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder49.setVertexBuffer(1, buffer294, 0, 1_166);
} catch {}
try {
renderBundleEncoder62.setBindGroup(2, bindGroup139);
} catch {}
try {
renderBundleEncoder62.setIndexBuffer(buffer34, 'uint16', 9_216, 1_909);
} catch {}
let bindGroup278 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 124, resource: textureView175},
    {binding: 136, resource: textureView435},
    {binding: 29, resource: textureView166},
    {binding: 7, resource: textureView210},
    {binding: 112, resource: sampler33},
  ],
});
let externalTexture67 = device0.importExternalTexture({source: videoFrame50});
try {
computePassEncoder216.setBindGroup(2, bindGroup211);
} catch {}
try {
renderPassEncoder49.setBindGroup(2, bindGroup268);
} catch {}
try {
renderPassEncoder9.drawIndexed(27, 4, 28, 411_855_731);
} catch {}
let arrayBuffer48 = buffer211.getMappedRange(248, 16);
let buffer349 = device0.createBuffer({
  size: 28255,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let querySet61 = device0.createQuerySet({type: 'occlusion', count: 1240});
let sampler270 = device0.createSampler({
  label: '\u05aa\u8943\u2ede\u0d2a',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 64.15,
  lodMaxClamp: 83.29,
});
try {
computePassEncoder51.setBindGroup(1, bindGroup258, new Uint32Array(1773), 1_081, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer18, 1_852);
} catch {}
try {
renderBundleEncoder62.setIndexBuffer(buffer72, 'uint32', 3_272, 1_108);
} catch {}
let arrayBuffer49 = buffer162.getMappedRange(184, 8);
try {
device0.queue.writeBuffer(buffer92, 1572, new BigUint64Array(3324), 420, 20);
} catch {}
let sampler271 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 16.51,
});
try {
computePassEncoder177.setBindGroup(0, bindGroup127, new Uint32Array(5356), 1_240, 0);
} catch {}
try {
computePassEncoder115.end();
} catch {}
try {
renderPassEncoder36.setBindGroup(1, bindGroup177);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup34, new Uint32Array(2392), 31, 0);
} catch {}
try {
renderPassEncoder9.draw(3, 6, 707_533_481, 2);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer102, 280);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder51.setVertexBuffer(1, buffer184);
} catch {}
try {
renderBundleEncoder62.setBindGroup(2, bindGroup175, new Uint32Array(1752), 60, 0);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let bindGroup279 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [
    {binding: 159, resource: textureView254},
    {binding: 31, resource: textureView201},
    {binding: 208, resource: textureView232},
  ],
});
let querySet62 = device0.createQuerySet({type: 'occlusion', count: 639});
let texture484 = device0.createTexture({
  label: '\u28bf\u4d02\u{1f7a1}\u{1f80b}\u020f\uaf98\u0db8\u{1fa49}',
  size: [161],
  dimension: '1d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder236 = commandEncoder136.beginComputePass({label: '\u{1fd9b}\u{1f813}\u027e\u04a3\u{1f66b}\u45b1'});
let sampler272 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 42.12,
  lodMaxClamp: 99.53,
});
try {
computePassEncoder78.setBindGroup(2, bindGroup224);
} catch {}
try {
computePassEncoder72.setBindGroup(2, bindGroup271, new Uint32Array(2010), 158, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup79);
} catch {}
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder17.setViewport(8.27437747911809, 22.029115778032686, 8.462131609535104, 12.110709591290165, 0.5932535057763827, 0.9969459773388588);
} catch {}
try {
commandEncoder35.copyBufferToTexture({
  /* bytesInLastRow: 416 widthInBlocks: 52 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1800 */
  offset: 1800,
  bytesPerRow: 13056,
  buffer: buffer250,
}, {
  texture: texture336,
  mipLevel: 0,
  origin: {x: 55, y: 0, z: 9},
  aspect: 'all',
}, {width: 52, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 55, height: 8, depthOrArrayLayers: 312}
*/
{
  source: canvas0,
  origin: { x: 7, y: 23 },
  flipY: true,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 26},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer350 = device0.createBuffer({size: 14523, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let querySet63 = device0.createQuerySet({type: 'occlusion', count: 170});
let computePassEncoder237 = commandEncoder35.beginComputePass({});
try {
computePassEncoder125.setBindGroup(0, bindGroup167, new Uint32Array(175), 2, 0);
} catch {}
try {
computePassEncoder237.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder54.setIndexBuffer(buffer252, 'uint32', 676, 529);
} catch {}
let buffer351 = device0.createBuffer({size: 16162, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView496 = texture388.createView({label: '\u9e0a\u{1ff8e}\u0f53\u{1f803}\u0b41\uf6ba\ue5e7\u0729\u{1fba2}'});
try {
computePassEncoder66.setBindGroup(1, bindGroup198);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer282, 'uint32', 12, 39);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture216,
  mipLevel: 0,
  origin: {x: 12, y: 1, z: 5},
  aspect: 'all',
}, new Uint8Array(536).fill(244), /* required buffer size: 536 */
{offset: 536, bytesPerRow: 6}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 161, height: 1, depthOrArrayLayers: 59}
*/
{
  source: videoFrame63,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture364,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView497 = texture132.createView({dimension: '2d', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder177); computePassEncoder177.dispatchWorkgroupsIndirect(buffer4, 1_180); };
} catch {}
try {
computePassEncoder236.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup171, new Uint32Array(611), 98, 0);
} catch {}
try {
renderBundleEncoder62.setBindGroup(0, bindGroup263);
} catch {}
try {
renderBundleEncoder62.setVertexBuffer(7, buffer219, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
document.body.prepend(img2);
let buffer352 = device0.createBuffer({
  size: 5213,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
{ clearResourceUsages(device0, computePassEncoder177); computePassEncoder177.dispatchWorkgroupsIndirect(buffer325, 8); };
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: 46.31, g: 812.0, b: -113.5, a: 380.9, });
} catch {}
try {
renderPassEncoder51.setScissorRect(0, 3, 10, 7);
} catch {}
try {
renderBundleEncoder62.setBindGroup(3, bindGroup275);
} catch {}
try {
renderBundleEncoder62.setBindGroup(3, bindGroup253, new Uint32Array(2943), 401, 0);
} catch {}
try {
buffer323.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 1}
*/
{
  source: imageData51,
  origin: { x: 52, y: 0 },
  flipY: false,
}, {
  texture: texture152,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 12, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas4);
let textureView498 = texture222.createView({dimension: '2d', arrayLayerCount: 1});
try {
computePassEncoder160.setBindGroup(1, bindGroup192, new Uint32Array(28), 3, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder44.setVertexBuffer(2, buffer136);
} catch {}
let arrayBuffer50 = buffer162.getMappedRange(192, 20);
let buffer353 = device0.createBuffer({
  label: '\udbde\u01c9\u57de\u069a',
  size: 1312,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let texture485 = device0.createTexture({
  size: {width: 645, height: 4, depthOrArrayLayers: 33},
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder177); computePassEncoder177.dispatchWorkgroupsIndirect(buffer328, 864); };
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer48, 'uint16', 124, 805);
} catch {}
let bindGroup280 = device0.createBindGroup({
  layout: bindGroupLayout55,
  entries: [
    {binding: 253, resource: textureView275},
    {binding: 199, resource: textureView284},
    {binding: 183, resource: textureView285},
    {binding: 184, resource: textureView470},
    {binding: 166, resource: sampler50},
    {binding: 198, resource: textureView222},
    {binding: 57, resource: externalTexture43},
    {binding: 7, resource: {buffer: buffer294, offset: 0, size: 1588}},
    {binding: 112, resource: textureView173},
  ],
});
let pipelineLayout31 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture486 = device0.createTexture({
  size: [104, 80, 128],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder2.setVertexBuffer(7, buffer220, 52, 117);
} catch {}
try {
renderBundleEncoder62.setBindGroup(2, bindGroup110, new Uint32Array(167), 37, 0);
} catch {}
try {
renderBundleEncoder62.setVertexBuffer(0, buffer281);
} catch {}
let texture487 = device0.createTexture({
  label: '\u2cdf\u0c1b\u343a\u0f76\u{1f727}\u950f\u7ff1\u092e\ucb79\ue0c1\u{1fa3b}',
  size: {width: 645, height: 4, depthOrArrayLayers: 5},
  format: 'stencil8',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder207.setBindGroup(0, bindGroup179);
} catch {}
try {
computePassEncoder18.setBindGroup(2, bindGroup6, new Uint32Array(703), 134, 0);
} catch {}
try {
renderPassEncoder44.executeBundles([renderBundle1, renderBundle49, renderBundle1]);
} catch {}
try {
renderPassEncoder53.setVertexBuffer(3, buffer121);
} catch {}
try {
renderBundleEncoder62.setIndexBuffer(buffer251, 'uint16', 14_504, 5_097);
} catch {}
try {
buffer171.unmap();
} catch {}
try {
renderBundleEncoder62.insertDebugMarker('\u{1fea7}');
} catch {}
let bindGroup281 = device0.createBindGroup({
  layout: bindGroupLayout53,
  entries: [
    {binding: 30, resource: textureView454},
    {binding: 138, resource: textureView95},
    {binding: 269, resource: sampler99},
    {binding: 456, resource: textureView211},
  ],
});
let texture488 = device0.createTexture({
  size: {width: 13},
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle62 = renderBundleEncoder62.finish();
try {
computePassEncoder49.setBindGroup(3, bindGroup76);
} catch {}
let arrayBuffer51 = buffer305.getMappedRange(32, 0);
try {
device0.queue.writeBuffer(buffer94, 288, new DataView(new ArrayBuffer(16080)), 1555, 408);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let sampler273 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 83.26,
  lodMaxClamp: 93.83,
  maxAnisotropy: 7,
});
let externalTexture68 = device0.importExternalTexture({source: videoFrame30});
try {
computePassEncoder207.setBindGroup(3, bindGroup271, new Uint32Array(1581), 282, 0);
} catch {}
let bindGroup282 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 59, resource: textureView457},
    {binding: 134, resource: externalTexture9},
    {binding: 104, resource: textureView487},
    {binding: 146, resource: {buffer: buffer207, offset: 0}},
    {binding: 420, resource: sampler76},
    {binding: 56, resource: externalTexture55},
    {binding: 133, resource: sampler196},
    {binding: 68, resource: sampler28},
    {binding: 132, resource: {buffer: buffer239, offset: 0, size: 100}},
    {binding: 140, resource: textureView62},
    {binding: 307, resource: {buffer: buffer337, offset: 768}},
    {binding: 76, resource: {buffer: buffer225, offset: 1792, size: 1828}},
    {binding: 128, resource: {buffer: buffer138, offset: 512, size: 2129}},
    {binding: 525, resource: {buffer: buffer167, offset: 0, size: 129}},
    {binding: 61, resource: {buffer: buffer5, offset: 3840}},
    {binding: 388, resource: textureView178},
    {binding: 193, resource: sampler129},
    {binding: 161, resource: {buffer: buffer62, offset: 256}},
    {binding: 384, resource: {buffer: buffer169, offset: 0, size: 828}},
    {binding: 0, resource: sampler13},
    {binding: 35, resource: textureView1},
    {binding: 22, resource: {buffer: buffer351, offset: 2304, size: 2199}},
    {binding: 217, resource: textureView123},
    {binding: 107, resource: {buffer: buffer172, offset: 256, size: 4257}},
    {binding: 46, resource: textureView55},
    {binding: 51, resource: {buffer: buffer14, offset: 768, size: 320}},
    {binding: 84, resource: externalTexture12},
    {binding: 158, resource: textureView225},
    {binding: 87, resource: sampler256},
    {binding: 160, resource: sampler60},
    {binding: 66, resource: textureView255},
    {binding: 45, resource: sampler94},
    {binding: 90, resource: externalTexture27},
    {binding: 58, resource: textureView252},
    {binding: 64, resource: {buffer: buffer75, offset: 1536, size: 632}},
    {binding: 119, resource: externalTexture51},
    {binding: 154, resource: sampler85},
    {binding: 81, resource: textureView100},
    {binding: 201, resource: textureView267},
    {binding: 177, resource: sampler111},
    {binding: 309, resource: {buffer: buffer296, offset: 2560, size: 820}},
    {binding: 114, resource: textureView351},
    {binding: 137, resource: {buffer: buffer243, offset: 1280, size: 2103}},
    {binding: 20, resource: {buffer: buffer119, offset: 3840, size: 450}},
    {binding: 18, resource: sampler260},
    {binding: 44, resource: sampler55},
    {binding: 130, resource: {buffer: buffer176, offset: 2304, size: 6313}},
    {binding: 29, resource: textureView109},
    {binding: 21, resource: {buffer: buffer284, offset: 512, size: 14800}},
    {binding: 75, resource: textureView97},
    {binding: 191, resource: sampler77},
    {binding: 19, resource: textureView197},
    {binding: 67, resource: externalTexture3},
    {binding: 216, resource: sampler177},
    {binding: 98, resource: {buffer: buffer352, offset: 2560, size: 149}},
    {binding: 65, resource: textureView270},
    {binding: 8, resource: sampler14},
    {binding: 381, resource: {buffer: buffer250, offset: 1536, size: 3452}},
    {binding: 413, resource: textureView64},
    {binding: 153, resource: textureView100},
    {binding: 136, resource: textureView100},
    {binding: 280, resource: sampler177},
  ],
});
let texture489 = device0.createTexture({
  size: {width: 645},
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder146.setBindGroup(1, bindGroup274, new Uint32Array(4243), 13, 1);
} catch {}
try {
computePassEncoder177.end();
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer101, 'uint16', 214, 88);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture405,
  mipLevel: 0,
  origin: {x: 16, y: 3, z: 23},
  aspect: 'all',
}, new Uint8Array(273_671).fill(212), /* required buffer size: 273_671 */
{offset: 103, bytesPerRow: 166, rowsPerImage: 16}, {width: 18, height: 0, depthOrArrayLayers: 104});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let renderPassEncoder56 = commandEncoder218.beginRenderPass({
  colorAttachments: [{
  view: textureView68,
  clearValue: { r: 916.4, g: -681.2, b: 430.1, a: 586.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler274 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 0.2201,
  lodMaxClamp: 27.11,
});
try {
renderPassEncoder32.beginOcclusionQuery(39);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle39, renderBundle4]);
} catch {}
try {
computePassEncoder53.setBindGroup(2, bindGroup115);
} catch {}
try {
computePassEncoder205.setBindGroup(2, bindGroup125, new Uint32Array(1140), 72, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
let bindGroup283 = device0.createBindGroup({
  label: '\u{1fea6}\u{1fb6a}\u806a\u4a50\u0a16\u{1fb8f}\u0e95',
  layout: bindGroupLayout56,
  entries: [
    {binding: 64, resource: sampler52},
    {binding: 117, resource: externalTexture12},
    {binding: 86, resource: textureView213},
    {binding: 440, resource: textureView100},
    {binding: 205, resource: {buffer: buffer84, offset: 4864, size: 2088}},
  ],
});
let querySet64 = device0.createQuerySet({type: 'occlusion', count: 112});
let texture490 = device0.createTexture({
  label: '\u16cb\u1ba8\u0b49\u0936\u{1ff9e}\u{1fd93}\u56bf',
  size: {width: 110, height: 16, depthOrArrayLayers: 625},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder233.setBindGroup(1, bindGroup91, new Uint32Array(1098), 126, 0);
} catch {}
try {
renderPassEncoder55.setBindGroup(1, bindGroup57);
} catch {}
try {
renderPassEncoder32.endOcclusionQuery();
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer292, 1028, new Float32Array(9667), 1571, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture119,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(96).fill(97), /* required buffer size: 96 */
{offset: 96, bytesPerRow: 76}, {width: 30, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 20, depthOrArrayLayers: 34}
*/
{
  source: videoFrame24,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture233,
  mipLevel: 1,
  origin: {x: 8, y: 3, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u7652\uda30\u138a\u5774';
} catch {}
let texture491 = device0.createTexture({
  size: {width: 1290, height: 8, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder206.setBindGroup(0, bindGroup279, new Uint32Array(258), 101, 0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline3);
} catch {}
let buffer354 = device0.createBuffer({
  size: 26885,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder28.setBindGroup(1, bindGroup118);
} catch {}
try {
renderPassEncoder42.beginOcclusionQuery(10);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(4, buffer158, 0, 1_956);
} catch {}
try {
  await buffer244.mapAsync(GPUMapMode.READ, 64, 328);
} catch {}
let bindGroup284 = device0.createBindGroup({
  label: '\u{1f6a2}\ud2fd\u60bd\u0767\u{1fb2c}\u3a6a\u9a95',
  layout: bindGroupLayout52,
  entries: [{binding: 100, resource: textureView333}],
});
let textureView499 = texture384.createView({dimension: '2d-array'});
try {
renderPassEncoder54.setBindGroup(1, bindGroup126, new Uint32Array(550), 122, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter0.label = '\u6ba8\u{1f669}\u748a\ua89b';
} catch {}
let buffer355 = device0.createBuffer({size: 4149, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let sampler275 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 54.81,
  lodMaxClamp: 81.06,
});
try {
renderPassEncoder56.setBindGroup(1, bindGroup102);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup4, new Uint32Array(1651), 635, 0);
} catch {}
try {
renderPassEncoder42.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer34, 'uint16', 4_736, 2_591);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let bindGroup285 = device0.createBindGroup({
  layout: bindGroupLayout24,
  entries: [
    {binding: 197, resource: {buffer: buffer18, offset: 768, size: 1804}},
    {binding: 46, resource: textureView407},
  ],
});
let texture492 = device0.createTexture({
  size: [13, 2, 1],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture493 = device0.createTexture({
  size: {width: 161, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder29.insertDebugMarker('\u0fe6');
} catch {}
try {
if (!arrayBuffer29.detached) { new Uint8Array(arrayBuffer29).fill(0x55); };
} catch {}
try {
renderPassEncoder44.setBindGroup(3, bindGroup192, new Uint32Array(119), 2, 0);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer47, 'uint16', 510, 649);
} catch {}
try {
device0.queue.writeBuffer(buffer349, 1544, new BigUint64Array(30757), 5462, 108);
} catch {}
let textureView500 = texture406.createView({format: 'r16float'});
let sampler276 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 23.54,
  maxAnisotropy: 10,
});
try {
computePassEncoder174.setBindGroup(0, bindGroup16, new Uint32Array(1426), 11, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup97, new Uint32Array(2187), 620, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle26]);
} catch {}
try {
renderPassEncoder55.setVertexBuffer(5, buffer248, 0, 2_853);
} catch {}
try {
device0.queue.writeBuffer(buffer48, 4, new Int16Array(4223), 59, 28);
} catch {}
let buffer356 = device0.createBuffer({size: 19635, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
renderPassEncoder18.setBindGroup(1, bindGroup146);
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle34, renderBundle5]);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer307, 'uint32', 144, 1_844);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline3);
} catch {}
try {
if (!arrayBuffer45.detached) { new Uint8Array(arrayBuffer45).fill(0x55); };
} catch {}
let texture494 = device0.createTexture({
  size: {width: 110, height: 16, depthOrArrayLayers: 6},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler277 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 22.71,
  lodMaxClamp: 51.84,
  compare: 'equal',
  maxAnisotropy: 7,
});
try {
computePassEncoder74.setBindGroup(3, bindGroup67);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder46.setVertexBuffer(0, buffer171);
} catch {}
let buffer357 = device0.createBuffer({
  size: 20305,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let sampler278 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 79.67,
});
try {
computePassEncoder179.setBindGroup(0, bindGroup16);
} catch {}
try {
computePassEncoder103.setBindGroup(2, bindGroup129, new Uint32Array(299), 52, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer17, 'uint16', 3_440, 2_678);
} catch {}
let imageData56 = new ImageData(12, 16);
let buffer358 = device0.createBuffer({size: 4320, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView501 = texture467.createView({arrayLayerCount: 1});
let sampler279 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 59.57,
  lodMaxClamp: 79.64,
  maxAnisotropy: 17,
});
try {
renderPassEncoder7.setIndexBuffer(buffer81, 'uint32', 792, 3_287);
} catch {}
try {
computePassEncoder142.setBindGroup(0, bindGroup92);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder174); computePassEncoder174.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder55.setBindGroup(2, bindGroup152);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup257, new Uint32Array(2434), 635, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture282,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'stencil-only',
}, new Uint8Array(308).fill(182), /* required buffer size: 308 */
{offset: 308, bytesPerRow: 117, rowsPerImage: 88}, {width: 110, height: 16, depthOrArrayLayers: 0});
} catch {}
let bindGroup286 = device0.createBindGroup({
  label: '\u{1f7d5}\u{1fb1c}\uf128\u2727\u0496',
  layout: bindGroupLayout42,
  entries: [
    {binding: 43, resource: sampler68},
    {binding: 17, resource: textureView91},
    {binding: 59, resource: textureView459},
    {binding: 306, resource: sampler254},
    {binding: 31, resource: textureView395},
  ],
});
let textureView502 = texture129.createView({});
try {
computePassEncoder38.setBindGroup(3, bindGroup84, new Uint32Array(841), 62, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder174); computePassEncoder174.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup95);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder43.setVertexBuffer(7, buffer333, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 104, height: 80, depthOrArrayLayers: 1}
*/
{
  source: videoFrame27,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture428,
  mipLevel: 0,
  origin: {x: 4, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder179); computePassEncoder179.dispatchWorkgroupsIndirect(buffer264, 208); };
} catch {}
try {
renderPassEncoder30.setBindGroup(0, bindGroup262);
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle47, renderBundle14]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas5);
let bindGroup287 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 44, resource: sampler195},
    {binding: 35, resource: textureView284},
    {binding: 193, resource: sampler232},
    {binding: 525, resource: {buffer: buffer98, offset: 2816, size: 3972}},
    {binding: 51, resource: {buffer: buffer205, offset: 0, size: 1048}},
    {binding: 20, resource: {buffer: buffer310, offset: 0, size: 358}},
    {binding: 130, resource: {buffer: buffer258, offset: 14080, size: 6101}},
    {binding: 76, resource: {buffer: buffer122, offset: 0, size: 702}},
    {binding: 119, resource: externalTexture64},
    {binding: 136, resource: textureView108},
    {binding: 384, resource: {buffer: buffer246, offset: 768, size: 796}},
    {binding: 128, resource: {buffer: buffer309, offset: 3328, size: 2513}},
    {binding: 56, resource: externalTexture17},
    {binding: 64, resource: {buffer: buffer165, offset: 2560, size: 164}},
    {binding: 140, resource: textureView179},
    {binding: 21, resource: {buffer: buffer206, offset: 512, size: 1792}},
    {binding: 87, resource: sampler225},
    {binding: 201, resource: textureView454},
    {binding: 22, resource: {buffer: buffer148, offset: 5888, size: 1412}},
    {binding: 45, resource: sampler22},
    {binding: 66, resource: textureView255},
    {binding: 29, resource: textureView100},
    {binding: 81, resource: textureView110},
    {binding: 307, resource: {buffer: buffer294, offset: 0, size: 3673}},
    {binding: 154, resource: sampler213},
    {binding: 146, resource: {buffer: buffer224, offset: 3840, size: 712}},
    {binding: 68, resource: sampler29},
    {binding: 98, resource: {buffer: buffer348, offset: 512}},
    {binding: 158, resource: textureView385},
    {binding: 161, resource: {buffer: buffer97, offset: 0, size: 1269}},
    {binding: 177, resource: sampler87},
    {binding: 61, resource: {buffer: buffer260, offset: 4864, size: 998}},
    {binding: 134, resource: externalTexture44},
    {binding: 160, resource: sampler89},
    {binding: 58, resource: textureView252},
    {binding: 413, resource: textureView64},
    {binding: 217, resource: textureView55},
    {binding: 67, resource: externalTexture15},
    {binding: 388, resource: textureView282},
    {binding: 137, resource: {buffer: buffer294, offset: 256, size: 733}},
    {binding: 90, resource: externalTexture58},
    {binding: 309, resource: {buffer: buffer13, offset: 6656, size: 4660}},
    {binding: 0, resource: sampler140},
    {binding: 216, resource: sampler247},
    {binding: 65, resource: textureView270},
    {binding: 114, resource: textureView113},
    {binding: 104, resource: textureView58},
    {binding: 132, resource: {buffer: buffer139, offset: 0, size: 792}},
    {binding: 84, resource: externalTexture9},
    {binding: 59, resource: textureView495},
    {binding: 153, resource: textureView1},
    {binding: 420, resource: sampler165},
    {binding: 381, resource: {buffer: buffer92, offset: 768, size: 2984}},
    {binding: 18, resource: sampler76},
    {binding: 46, resource: textureView123},
    {binding: 75, resource: textureView426},
    {binding: 107, resource: {buffer: buffer136, offset: 1024, size: 1668}},
    {binding: 8, resource: sampler139},
    {binding: 19, resource: textureView109},
    {binding: 191, resource: sampler202},
    {binding: 133, resource: sampler257},
    {binding: 280, resource: sampler48},
  ],
});
let textureView503 = texture169.createView({aspect: 'all', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 28, arrayLayerCount: 6});
try {
renderPassEncoder14.setBindGroup(2, bindGroup79, new Uint32Array(25), 2, 0);
} catch {}
try {
renderPassEncoder44.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(4, buffer136, 10_984);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(img2);
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame5.close();
videoFrame6.close();
videoFrame7.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
videoFrame27.close();
videoFrame28.close();
videoFrame29.close();
videoFrame30.close();
videoFrame31.close();
videoFrame33.close();
videoFrame34.close();
videoFrame35.close();
videoFrame37.close();
videoFrame39.close();
videoFrame40.close();
videoFrame41.close();
videoFrame44.close();
videoFrame48.close();
videoFrame50.close();
videoFrame51.close();
videoFrame52.close();
videoFrame55.close();
videoFrame57.close();
videoFrame58.close();
videoFrame59.close();
videoFrame60.close();
videoFrame62.close();
videoFrame63.close();
videoFrame64.close();
videoFrame65.close();
videoFrame66.close();
videoFrame67.close();
videoFrame68.close();
videoFrame69.close();
videoFrame70.close();
videoFrame72.close();
videoFrame73.close();
videoFrame75.close();
videoFrame76.close();
videoFrame77.close();
videoFrame79.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?.notifyDone();
};
</script>